From 1dcade59953f1de3088075a1498803f5a4b70d98 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 10:27:11 +1000
Subject: [PATCH 01/45] forge install: foundry-playground

---
 .gitmodules                  | 3 +++
 forge/lib/foundry-playground | 1 +
 2 files changed, 4 insertions(+)
 create mode 160000 forge/lib/foundry-playground

diff --git a/.gitmodules b/.gitmodules
index fefdd27..d45e890 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -16,3 +16,6 @@
 [submodule "forge/lib/openzeppelin-contracts"]
 	path = forge/lib/openzeppelin-contracts
 	url = https://github.com/openzeppelin/openzeppelin-contracts
+[submodule "forge/lib/foundry-playground"]
+	path = forge/lib/foundry-playground
+	url = https://github.com/dekz/foundry-playground
diff --git a/forge/lib/foundry-playground b/forge/lib/foundry-playground
new file mode 160000
index 0000000..ae18323
--- /dev/null
+++ b/forge/lib/foundry-playground
@@ -0,0 +1 @@
+Subproject commit ae18323cbf6696e000e0770b6137f60842232411

From aef04d71c693f3bc4350bfe5e1057461c9974df6 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 11:32:20 +1000
Subject: [PATCH 02/45] add vUSDC vault and test

---
 forge/readme.md                    |  25 +++--
 forge/remappings.txt               |   2 +
 forge/src/interfaces/IBalancer.sol |  50 ++++++++++
 forge/src/interfaces/IRouter.sol   |   7 ++
 forge/src/interfaces/IStargate.sol |  16 +++
 forge/src/test/Contract.t.sol      |  12 ---
 forge/src/test/vUSDC.t.sol         | 107 ++++++++++++++++++++
 forge/src/vUSDC.sol                | 152 +++++++++++++++++++++++++++++
 8 files changed, 349 insertions(+), 22 deletions(-)
 create mode 100644 forge/src/interfaces/IBalancer.sol
 create mode 100644 forge/src/interfaces/IRouter.sol
 create mode 100644 forge/src/interfaces/IStargate.sol
 delete mode 100644 forge/src/test/Contract.t.sol
 create mode 100644 forge/src/test/vUSDC.t.sol
 create mode 100644 forge/src/vUSDC.sol

diff --git a/forge/readme.md b/forge/readme.md
index 2c8e24c..89e4c03 100644
--- a/forge/readme.md
+++ b/forge/readme.md
@@ -1,10 +1,11 @@
-# Tracer Skew Farming Vault
-WIP
+# vUSDC Vault
+Vault that accepts underlying (USDC) and deposits into stargate to collect and compound STG rewards into more underlying.
+Swaps are conducted through Blancer on Arbitrum. This vault is configured for arbitrum, but tested working on ETH Mainnet. 
+Too launch on another network supporting stargate, simply change the `underyling` `router` `POOLTOKEN` and `staker` addresses. 
+Rewards are compounded with an independent function by the vault owner, but can be configured to compound on deposit through a nested if statement. 
+To add a `fee` call the `setFee` function, fees are collected on every compound and sent to the `feeCollector`. 
 
-## Goal
-To farm the skew between long and short positions on chain.
-
-## Getting Started
+## Install foundry
 you will need foundry installed to compile and test contracts in ./forge/src
 ```
 curl -L https://foundry.paradigm.xyz | bash
@@ -13,6 +14,7 @@ then install foundry using
 ```
 foundryup
 ```
+## Getting started
 update lib's using
 ```
 forge update
@@ -25,8 +27,11 @@ lint using
 ```
 yarn run lint
 ```
+## Testing
+To test vUSDC, run the following command:
+```
+forge t  -vvvv  --fork-url https://arb-mainnet.g.alchemy.com/v2/vkR4jribNoIWslgAymd5F8zQ1Ny8y9xL --fork-block-number 8623683 
+```
+The above test forks the Arbitrum network at block `8623683` and interaacts with stargate through the vault by replicating user deposits, withdrawals and compounds
 
-## TO-DO
-- long vault
-- short vault
-- tests
\ No newline at end of file
+To test reward reciept, `testRewards()` will need to be uncommented and the test run on ETH Mainnet. 
\ No newline at end of file
diff --git a/forge/remappings.txt b/forge/remappings.txt
index b1b9032..c783553 100644
--- a/forge/remappings.txt
+++ b/forge/remappings.txt
@@ -1,3 +1,4 @@
+src/=./forge/src/
 solmate/=lib/solmate/src/
 weird-erc20/=lib/solmate/lib/weird-erc20/src/
 ds-test/=lib/ds-test/src/
@@ -5,3 +6,4 @@ openzeppelin/=lib/openzeppelin-contracts/contracts/
 foundry-playground/=lib/foundry-playground/src/
 tracer/=lib/perpetual-pools-contracts/contracts/
 abdk-libraries-solidity/=lib/abdk-libraries-solidity/
+
diff --git a/forge/src/interfaces/IBalancer.sol b/forge/src/interfaces/IBalancer.sol
new file mode 100644
index 0000000..f360b36
--- /dev/null
+++ b/forge/src/interfaces/IBalancer.sol
@@ -0,0 +1,50 @@
+pragma solidity ^0.8.6;
+
+interface IAsset {}
+
+interface IBalancer {
+    enum SwapKind {
+        GIVEN_IN,
+        GIVEN_OUT
+    }
+
+    struct FundManagement {
+        address sender;
+        bool fromInternalBalance;
+        address payable recipient;
+        bool toInternalBalance;
+    }
+
+    struct SingleSwap {
+        bytes32 poolId;
+        SwapKind kind;
+        IAsset assetIn;
+        IAsset assetOut;
+        uint256 amount;
+        bytes userData;
+    }
+
+    struct BatchSwapStep {
+        bytes32 poolId;
+        uint256 assetInIndex;
+        uint256 assetOutIndex;
+        uint256 amount;
+        bytes userData;
+    }
+
+    function swap(
+        SingleSwap calldata singleSwap,
+        FundManagement calldata funds,
+        uint256 limit,
+        uint256 deadline
+    ) external payable returns (uint256 amountCalculated);
+
+    function batchSwap(
+        SwapKind kind,
+        BatchSwapStep[] calldata swaps,
+        IAsset[] calldata assets,
+        FundManagement calldata funds,
+        int256[] calldata limits,
+        uint256 deadline
+    ) external payable returns (int256[] memory assetDeltas);
+}
\ No newline at end of file
diff --git a/forge/src/interfaces/IRouter.sol b/forge/src/interfaces/IRouter.sol
new file mode 100644
index 0000000..d1605d4
--- /dev/null
+++ b/forge/src/interfaces/IRouter.sol
@@ -0,0 +1,7 @@
+    // SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+interface IRouter {
+    function addLiquidity(uint256 _pid, uint256 _amount, address _to) external;
+    function instantRedeemLocal(uint16 _pid, uint256 _amountLP, address _to) external returns (uint256);
+}
\ No newline at end of file
diff --git a/forge/src/interfaces/IStargate.sol b/forge/src/interfaces/IStargate.sol
new file mode 100644
index 0000000..0de28d6
--- /dev/null
+++ b/forge/src/interfaces/IStargate.sol
@@ -0,0 +1,16 @@
+    // SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+interface IStargate  {
+        struct UserInfo {
+        uint256 amount; // How many LP tokens the user has provided.
+        uint256 rewardDebt; // Reward debt. See explanation below.
+        }
+    function userInfo(uint256 _pid, address _user)
+        external
+        view
+        returns (uint256, uint256);
+
+    function deposit(uint256 _pid, uint256 _amount) external;
+    function withdraw(uint256 _pid, uint256 _amount) external;
+}
\ No newline at end of file
diff --git a/forge/src/test/Contract.t.sol b/forge/src/test/Contract.t.sol
deleted file mode 100644
index 10bf1a6..0000000
--- a/forge/src/test/Contract.t.sol
+++ /dev/null
@@ -1,12 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity 0.8.10;
-
-import "ds-test/test.sol";
-
-contract ContractTest is DSTest {
-    function setUp() public {}
-
-    function testExample() public {
-        assertTrue(true);
-    }
-}
diff --git a/forge/src/test/vUSDC.t.sol b/forge/src/test/vUSDC.t.sol
new file mode 100644
index 0000000..0dbc67a
--- /dev/null
+++ b/forge/src/test/vUSDC.t.sol
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+import "ds-test/test.sol";
+import {vUSDC} from "../vUSDC.sol";
+import "foundry-playground/ERC20TokenFaker.sol";
+import "foundry-playground/FakeERC20.sol";
+
+import {ERC20, ERC4626} from "solmate/mixins/ERC4626.sol";
+import "openzeppelin/utils/Strings.sol";
+import {IStargate} from "../interfaces/IStargate.sol";
+
+interface Vm {
+    function warp(uint256 x) external;
+    function expectRevert(bytes calldata) external;
+    function roll(uint256) external;
+    function prank(address) external;
+}
+
+contract vUSDCtest is DSTest, ERC20TokenFaker {
+    uint256 count;
+    vUSDC vusd;
+    FakeERC20 fakeUSDC;
+    ERC20 UNDERLYING;
+    FakeERC20 fakeSTG;
+     Vm constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
+    
+
+
+function setUp() public {
+    fakeUSDC = fakeOutERC20(address(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8));
+    fakeUSDC._setBalance(address(this), 1e18);
+    vusd = new vUSDC(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8, "vault", "vlt");
+    vusd.setFee(10);
+    vusd.setFeeCollector(address((this)));
+    ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).approve(address(vusd), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+    ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(address(this), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+    ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(address(vusd), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+    ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(0xeA8DfEE1898a7e0a59f7527F076106d7e44c2176, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+    ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(address(vusd), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+    ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(address(this), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+    ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(0x53Bf833A5d6c4ddA888F69c22C88C9f356a41614, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+    vusd.deposit(1000000000, address(this));
+}
+function testInitialBalance() public {
+    assertEq(1000000000, vusd.balanceOf(address(this)));
+}
+// // test whole deposit flow
+function testDeposit() public {
+    uint256 bal = vusd.balanceOf(address(this));
+    vusd.deposit(1000000, address(this));
+    //  assert(vusd.balanceOf(address(this)) > 1);
+    assert(vusd.balanceOf(address(this))  > bal);
+    emit log("deposit");
+}
+function testDepositCompound() public {
+    fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
+    fakeSTG._setBalance(address(vusd), 1e18);
+    vm.warp(2 days);
+    vusd.deposit(100000, address(this));
+
+}
+
+// test just reciept of LP tokens (comment out stake)
+// function testLP() public {
+//     ERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48).approve(address(vusd), 10000000000000);
+//     vusd.approve(address(vusd), 10000000000000);
+//     ERC20(0xdf0770dF86a8034b3EFEf0A1Bb3c889B8332FF56).approve(address(vusd), 10000000000000);
+//     vusd.deposit(100000000, address(this));
+//     assert(ERC20(0xdf0770dF86a8034b3EFEf0A1Bb3c889B8332FF56).balanceOf(address(vusd)) >= 1);
+// }
+// // test reciept of stg tokens on deposit fast forward
+// function testRewards() public {
+//     vusd.deposit(1000000000000, address(this));
+//     vusd.stake();
+//     vm.warp(1 days);
+//     vusd.deposit(1000, address(this));
+//     vusd.stake();
+//    assert(ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).balanceOf(address(vusd)) > 0);
+// }
+//change withdraw logic so assets are representing staked balance
+function testWithdraw() public {
+    vusd.withdraw(1000000, address(this), address(this));
+    emit log("withdraw");
+}
+function testLPStats() public {
+    assert(vusd.lpStats() >0);
+}
+
+function testCompound() public {
+    fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
+    fakeSTG._setBalance(address(vusd), 1e18);
+    uint256 _pb = vusd.value();
+    vusd.compound();
+    uint256 _nb = vusd.value();
+    assert(_nb > _pb);
+}
+function testCompoundWithFee() public {
+    vusd.setFee(10000);
+    fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
+    fakeSTG._setBalance(address(vusd), 1e18);
+    uint256 _pb = vusd.value();
+    vusd.compound();
+    uint256 _nb = vusd.value();
+    assert(_nb > _pb);
+}
+}
diff --git a/forge/src/vUSDC.sol b/forge/src/vUSDC.sol
new file mode 100644
index 0000000..9af765c
--- /dev/null
+++ b/forge/src/vUSDC.sol
@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+import "solmate/mixins/ERC4626.sol";
+import {ERC20} from "solmate/tokens/ERC20.sol";
+import {IStargate} from "./interfaces/IStargate.sol";
+import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";
+import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
+import {Ownable} from "openzeppelin/access/Ownable.sol";
+import {IRouter} from "./interfaces/IRouter.sol";
+import {IAsset, IBalancer} from "./interfaces/IBalancer.sol";
+import {IERC20} from "openzeppelin/token/ERC20/IERC20.sol";
+// import {ERC20} from "forge/lib/solmate/src/tokens/ERC20.sol";
+// import {IStargate} from "./interfaces/IStargate.sol";
+// import {FixedPointMathLib} from "forge/lib/solmate/src/utils/FixedPointMathLib.sol";
+// import {SafeTransferLib} from "forge/lib/solmate/src/utils/SafeTransferLib.sol";
+// import {Ownable} from "forge/lib/openzeppelin-contracts/contracts/access/Ownable.sol";
+// import {IRouter} from "./interfaces/IRouter.sol";
+// import {IAsset, IBalancer} from "./interfaces/IBalancer.sol";
+// import {IERC20} from "forge/lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+
+// Vault for depositing underlying (usdc) into stargate, compounding STG rewards through balancer for more underlying
+contract vUSDC is ERC4626, Ownable{
+    using FixedPointMathLib for uint256;
+    event balancerSwap(uint256 _amt);
+    event staked(uint256 _amt);
+    event stgBal(uint256 _stgBal);
+    event feeCollected(uint256 _amt);
+    event Log(string message);
+
+    //usdc
+    ERC20 public immutable UNDERLYING;
+    //pUSDC
+    ERC20 public immutable POOLTOKEN;
+    //stg token
+    ERC20 public STG;
+    //stg contract, import interface
+    IStargate public staker;
+    //fee collector
+    address public feeCollector;
+    //stargate pool ID (usd = 1)
+    //router
+    IRouter public immutable router;
+    //deposit fee
+    uint256 public fee;
+    bytes32 public immutable _balancerPool =
+        0x3a4c6d2404b5eb14915041e01f63200a82f4a343000200000000000000000065; //arbitrum balancer vault
+    
+    constructor(address _underlying, string memory name, string memory symbol) ERC4626(ERC20(_underlying), name, symbol){
+        UNDERLYING = ERC20(_underlying);
+        router = IRouter(0x53Bf833A5d6c4ddA888F69c22C88C9f356a41614); //arbitrum router
+        staker = IStargate(0xeA8DfEE1898a7e0a59f7527F076106d7e44c2176); //Arbitrum LP staker
+        POOLTOKEN = ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e); //Arbitrum USDC LP token
+        STG = ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6); //Arbitrum STG reward token
+        UNDERLYING.approve(address(router), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+        POOLTOKEN.approve(address(staker), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+        STG.approve(0xBA12222222228d8Ba445958a75a0704d566BF2C8,  0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+        STG.approve(0xeA8DfEE1898a7e0a59f7527F076106d7e44c2176,  0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+    }
+    function totalAssets() public view virtual override returns (uint256){
+         return value();
+    }
+    // $ per LP token
+    function lpStats() public view virtual returns (uint256){
+        uint256 sup= POOLTOKEN.totalSupply();
+        uint256 bal = UNDERLYING.balanceOf(address(POOLTOKEN));
+        return bal.divWadDown(sup);
+    }
+    function value() public view returns(uint256) {
+       (uint256 amount, ) = staker.userInfo(
+            0,
+            address(this)
+        );
+        return amount.mulWadDown(lpStats());
+    }
+    function lpPerShare() public view returns(uint256) {
+        (uint256 amount, ) = staker.userInfo(
+            0,
+            address(this)
+        );
+        return amount.divWadDown(totalSupply);
+    }
+    function afterDeposit(uint256 assets, uint256 shares)internal virtual override {
+        router.addLiquidity(1, assets, address(this));
+        stake();
+    }
+    function stake() internal {
+        uint256 _bal = POOLTOKEN.balanceOf(address(this));
+        staker.deposit(0, _bal);
+    }
+    function beforeWithdraw(uint256 assets, uint256 shares)internal virtual override {
+        uint256 lpWant = lpPerShare().mulWadDown(shares);
+        IStargate(staker).withdraw(0, lpWant);
+        router.instantRedeemLocal(1, lpWant, address(this));
+        require(UNDERLYING.balanceOf(address(this)) > 0, "no underlying");
+    }
+
+    function assetsToLp(uint256 assets) public view returns(uint256){
+        return assets.divWadDown(lpStats());
+    }
+    function setFee(uint256 _fee)public onlyOwner{
+        fee = _fee;
+    }
+    function setStaker(address _staker)public onlyOwner{
+        staker = IStargate(_staker);
+    }
+    function setFeeCollector(address _feeCollector)public onlyOwner{
+        feeCollector = _feeCollector;
+    }
+    //swap on balancer stg for more USDC, add liquidity, stake.
+    function compound() public onlyOwner{
+        uint256 _stg = STG.balanceOf(address(this));
+        if(_stg > 1){
+         IBalancer.SingleSwap memory swapParams = IBalancer
+            .SingleSwap({
+            poolId: _balancerPool,
+            kind: IBalancer.SwapKind.GIVEN_IN,
+            //STG token
+            assetIn: IAsset(0x6694340fc020c5E6B96567843da2df01b2CE1eb6),
+            //USDC
+            assetOut: IAsset(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8),
+            amount: _stg,
+            userData: "0x"
+         });
+        IBalancer.FundManagement memory funds = IBalancer
+        .FundManagement({
+            sender: address(this),
+            recipient: payable(address(this)),
+            fromInternalBalance: false,
+            toInternalBalance: false
+        });
+    // perform swap
+    IBalancer(0xBA12222222228d8Ba445958a75a0704d566BF2C8).swap(swapParams, funds, 1, block.timestamp + 60);
+    emit balancerSwap(_stg);
+    uint256 _underlying = ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).balanceOf(address(this));
+    if(fee > 0){
+        uint256 _fee = _underlying.mulWadDown(fee);
+        ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).transfer(feeCollector, _fee);
+        emit feeCollected(_fee);
+    }
+    uint256 underlying = ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).balanceOf(address(this));
+    // Deposit stablecoin liquidity
+    router.addLiquidity(
+        1,
+        underlying,
+        address(this)
+    );
+    stake();
+   emit staked(underlying);
+   emit Log("compounded");
+} return;
+    }
+}
\ No newline at end of file

From f666e610b46fd8865fdb572eeb50a91ee80ed90f Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 11:39:31 +1000
Subject: [PATCH 03/45] lint

---
 forge/src/interfaces/IBalancer.sol |   2 +-
 forge/src/interfaces/IRouter.sol   |  17 ++-
 forge/src/interfaces/IStargate.sol |  17 ++-
 forge/src/test/vUSDC.t.sol         | 178 +++++++++++++++++------------
 forge/src/vUSDC.sol                | 151 ++++++++++++------------
 5 files changed, 199 insertions(+), 166 deletions(-)

diff --git a/forge/src/interfaces/IBalancer.sol b/forge/src/interfaces/IBalancer.sol
index f360b36..b519a38 100644
--- a/forge/src/interfaces/IBalancer.sol
+++ b/forge/src/interfaces/IBalancer.sol
@@ -47,4 +47,4 @@ interface IBalancer {
         int256[] calldata limits,
         uint256 deadline
     ) external payable returns (int256[] memory assetDeltas);
-}
\ No newline at end of file
+}
diff --git a/forge/src/interfaces/IRouter.sol b/forge/src/interfaces/IRouter.sol
index d1605d4..31e2e6d 100644
--- a/forge/src/interfaces/IRouter.sol
+++ b/forge/src/interfaces/IRouter.sol
@@ -1,7 +1,16 @@
-    // SPDX-License-Identifier: AGPL-3.0-only
+// SPDX-License-Identifier: AGPL-3.0-only
 pragma solidity ^0.8.0;
 
 interface IRouter {
-    function addLiquidity(uint256 _pid, uint256 _amount, address _to) external;
-    function instantRedeemLocal(uint16 _pid, uint256 _amountLP, address _to) external returns (uint256);
-}
\ No newline at end of file
+    function addLiquidity(
+        uint256 _pid,
+        uint256 _amount,
+        address _to
+    ) external;
+
+    function instantRedeemLocal(
+        uint16 _pid,
+        uint256 _amountLP,
+        address _to
+    ) external returns (uint256);
+}
diff --git a/forge/src/interfaces/IStargate.sol b/forge/src/interfaces/IStargate.sol
index 0de28d6..19a8673 100644
--- a/forge/src/interfaces/IStargate.sol
+++ b/forge/src/interfaces/IStargate.sol
@@ -1,16 +1,15 @@
-    // SPDX-License-Identifier: AGPL-3.0-only
+// SPDX-License-Identifier: AGPL-3.0-only
 pragma solidity ^0.8.0;
 
-interface IStargate  {
-        struct UserInfo {
+interface IStargate {
+    struct UserInfo {
         uint256 amount; // How many LP tokens the user has provided.
         uint256 rewardDebt; // Reward debt. See explanation below.
-        }
-    function userInfo(uint256 _pid, address _user)
-        external
-        view
-        returns (uint256, uint256);
+    }
+
+    function userInfo(uint256 _pid, address _user) external view returns (uint256, uint256);
 
     function deposit(uint256 _pid, uint256 _amount) external;
+
     function withdraw(uint256 _pid, uint256 _amount) external;
-}
\ No newline at end of file
+}
diff --git a/forge/src/test/vUSDC.t.sol b/forge/src/test/vUSDC.t.sol
index 0dbc67a..3d7a7ee 100644
--- a/forge/src/test/vUSDC.t.sol
+++ b/forge/src/test/vUSDC.t.sol
@@ -12,8 +12,11 @@ import {IStargate} from "../interfaces/IStargate.sol";
 
 interface Vm {
     function warp(uint256 x) external;
+
     function expectRevert(bytes calldata) external;
+
     function roll(uint256) external;
+
     function prank(address) external;
 }
 
@@ -23,85 +26,108 @@ contract vUSDCtest is DSTest, ERC20TokenFaker {
     FakeERC20 fakeUSDC;
     ERC20 UNDERLYING;
     FakeERC20 fakeSTG;
-     Vm constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
-    
+    Vm constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
 
+    function setUp() public {
+        fakeUSDC = fakeOutERC20(address(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8));
+        fakeUSDC._setBalance(address(this), 1e18);
+        vusd = new vUSDC(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8, "vault", "vlt");
+        vusd.setFee(10);
+        vusd.setFeeCollector(address((this)));
+        ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).approve(
+            address(vusd),
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
+        ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(
+            address(this),
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
+        ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(
+            address(vusd),
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
+        ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(
+            0xeA8DfEE1898a7e0a59f7527F076106d7e44c2176,
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
+        ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(
+            address(vusd),
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
+        ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(
+            address(this),
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
+        ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(
+            0x53Bf833A5d6c4ddA888F69c22C88C9f356a41614,
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
+        vusd.deposit(1000000000, address(this));
+    }
 
-function setUp() public {
-    fakeUSDC = fakeOutERC20(address(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8));
-    fakeUSDC._setBalance(address(this), 1e18);
-    vusd = new vUSDC(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8, "vault", "vlt");
-    vusd.setFee(10);
-    vusd.setFeeCollector(address((this)));
-    ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).approve(address(vusd), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
-    ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(address(this), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
-    ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(address(vusd), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
-    ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(0xeA8DfEE1898a7e0a59f7527F076106d7e44c2176, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
-    ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(address(vusd), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
-    ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(address(this), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
-    ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(0x53Bf833A5d6c4ddA888F69c22C88C9f356a41614, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
-    vusd.deposit(1000000000, address(this));
-}
-function testInitialBalance() public {
-    assertEq(1000000000, vusd.balanceOf(address(this)));
-}
-// // test whole deposit flow
-function testDeposit() public {
-    uint256 bal = vusd.balanceOf(address(this));
-    vusd.deposit(1000000, address(this));
-    //  assert(vusd.balanceOf(address(this)) > 1);
-    assert(vusd.balanceOf(address(this))  > bal);
-    emit log("deposit");
-}
-function testDepositCompound() public {
-    fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
-    fakeSTG._setBalance(address(vusd), 1e18);
-    vm.warp(2 days);
-    vusd.deposit(100000, address(this));
+    function testInitialBalance() public {
+        assertEq(1000000000, vusd.balanceOf(address(this)));
+    }
 
-}
+    // // test whole deposit flow
+    function testDeposit() public {
+        uint256 bal = vusd.balanceOf(address(this));
+        vusd.deposit(1000000, address(this));
+        //  assert(vusd.balanceOf(address(this)) > 1);
+        assert(vusd.balanceOf(address(this)) > bal);
+        emit log("deposit");
+    }
 
-// test just reciept of LP tokens (comment out stake)
-// function testLP() public {
-//     ERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48).approve(address(vusd), 10000000000000);
-//     vusd.approve(address(vusd), 10000000000000);
-//     ERC20(0xdf0770dF86a8034b3EFEf0A1Bb3c889B8332FF56).approve(address(vusd), 10000000000000);
-//     vusd.deposit(100000000, address(this));
-//     assert(ERC20(0xdf0770dF86a8034b3EFEf0A1Bb3c889B8332FF56).balanceOf(address(vusd)) >= 1);
-// }
-// // test reciept of stg tokens on deposit fast forward
-// function testRewards() public {
-//     vusd.deposit(1000000000000, address(this));
-//     vusd.stake();
-//     vm.warp(1 days);
-//     vusd.deposit(1000, address(this));
-//     vusd.stake();
-//    assert(ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).balanceOf(address(vusd)) > 0);
-// }
-//change withdraw logic so assets are representing staked balance
-function testWithdraw() public {
-    vusd.withdraw(1000000, address(this), address(this));
-    emit log("withdraw");
-}
-function testLPStats() public {
-    assert(vusd.lpStats() >0);
-}
+    function testDepositCompound() public {
+        fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
+        fakeSTG._setBalance(address(vusd), 1e18);
+        vm.warp(2 days);
+        vusd.deposit(100000, address(this));
+    }
 
-function testCompound() public {
-    fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
-    fakeSTG._setBalance(address(vusd), 1e18);
-    uint256 _pb = vusd.value();
-    vusd.compound();
-    uint256 _nb = vusd.value();
-    assert(_nb > _pb);
-}
-function testCompoundWithFee() public {
-    vusd.setFee(10000);
-    fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
-    fakeSTG._setBalance(address(vusd), 1e18);
-    uint256 _pb = vusd.value();
-    vusd.compound();
-    uint256 _nb = vusd.value();
-    assert(_nb > _pb);
-}
+    // test just reciept of LP tokens (comment out stake)
+    // function testLP() public {
+    //     ERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48).approve(address(vusd), 10000000000000);
+    //     vusd.approve(address(vusd), 10000000000000);
+    //     ERC20(0xdf0770dF86a8034b3EFEf0A1Bb3c889B8332FF56).approve(address(vusd), 10000000000000);
+    //     vusd.deposit(100000000, address(this));
+    //     assert(ERC20(0xdf0770dF86a8034b3EFEf0A1Bb3c889B8332FF56).balanceOf(address(vusd)) >= 1);
+    // }
+    // // test reciept of stg tokens on deposit fast forward
+    // function testRewards() public {
+    //     vusd.deposit(1000000000000, address(this));
+    //     vusd.stake();
+    //     vm.warp(1 days);
+    //     vusd.deposit(1000, address(this));
+    //     vusd.stake();
+    //    assert(ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).balanceOf(address(vusd)) > 0);
+    // }
+    //change withdraw logic so assets are representing staked balance
+    function testWithdraw() public {
+        vusd.withdraw(1000000, address(this), address(this));
+        emit log("withdraw");
+    }
+
+    function testLPStats() public {
+        assert(vusd.lpStats() > 0);
+    }
+
+    function testCompound() public {
+        fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
+        fakeSTG._setBalance(address(vusd), 1e18);
+        uint256 _pb = vusd.value();
+        vusd.compound();
+        uint256 _nb = vusd.value();
+        assert(_nb > _pb);
+    }
+
+    function testCompoundWithFee() public {
+        vusd.setFee(10000);
+        fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
+        fakeSTG._setBalance(address(vusd), 1e18);
+        uint256 _pb = vusd.value();
+        vusd.compound();
+        uint256 _nb = vusd.value();
+        assert(_nb > _pb);
+    }
 }
diff --git a/forge/src/vUSDC.sol b/forge/src/vUSDC.sol
index 9af765c..decd354 100644
--- a/forge/src/vUSDC.sol
+++ b/forge/src/vUSDC.sol
@@ -9,17 +9,9 @@ import {Ownable} from "openzeppelin/access/Ownable.sol";
 import {IRouter} from "./interfaces/IRouter.sol";
 import {IAsset, IBalancer} from "./interfaces/IBalancer.sol";
 import {IERC20} from "openzeppelin/token/ERC20/IERC20.sol";
-// import {ERC20} from "forge/lib/solmate/src/tokens/ERC20.sol";
-// import {IStargate} from "./interfaces/IStargate.sol";
-// import {FixedPointMathLib} from "forge/lib/solmate/src/utils/FixedPointMathLib.sol";
-// import {SafeTransferLib} from "forge/lib/solmate/src/utils/SafeTransferLib.sol";
-// import {Ownable} from "forge/lib/openzeppelin-contracts/contracts/access/Ownable.sol";
-// import {IRouter} from "./interfaces/IRouter.sol";
-// import {IAsset, IBalancer} from "./interfaces/IBalancer.sol";
-// import {IERC20} from "forge/lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
 
 // Vault for depositing underlying (usdc) into stargate, compounding STG rewards through balancer for more underlying
-contract vUSDC is ERC4626, Ownable{
+contract vUSDC is ERC4626, Ownable {
     using FixedPointMathLib for uint256;
     event balancerSwap(uint256 _amt);
     event staked(uint256 _amt);
@@ -42,10 +34,13 @@ contract vUSDC is ERC4626, Ownable{
     IRouter public immutable router;
     //deposit fee
     uint256 public fee;
-    bytes32 public immutable _balancerPool =
-        0x3a4c6d2404b5eb14915041e01f63200a82f4a343000200000000000000000065; //arbitrum balancer vault
-    
-    constructor(address _underlying, string memory name, string memory symbol) ERC4626(ERC20(_underlying), name, symbol){
+    bytes32 public immutable _balancerPool = 0x3a4c6d2404b5eb14915041e01f63200a82f4a343000200000000000000000065; //arbitrum balancer vault
+
+    constructor(
+        address _underlying,
+        string memory name,
+        string memory symbol
+    ) ERC4626(ERC20(_underlying), name, symbol) {
         UNDERLYING = ERC20(_underlying);
         router = IRouter(0x53Bf833A5d6c4ddA888F69c22C88C9f356a41614); //arbitrum router
         staker = IStargate(0xeA8DfEE1898a7e0a59f7527F076106d7e44c2176); //Arbitrum LP staker
@@ -53,100 +48,104 @@ contract vUSDC is ERC4626, Ownable{
         STG = ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6); //Arbitrum STG reward token
         UNDERLYING.approve(address(router), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
         POOLTOKEN.approve(address(staker), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
-        STG.approve(0xBA12222222228d8Ba445958a75a0704d566BF2C8,  0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
-        STG.approve(0xeA8DfEE1898a7e0a59f7527F076106d7e44c2176,  0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+        STG.approve(
+            0xBA12222222228d8Ba445958a75a0704d566BF2C8,
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
+        STG.approve(
+            0xeA8DfEE1898a7e0a59f7527F076106d7e44c2176,
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
     }
-    function totalAssets() public view virtual override returns (uint256){
-         return value();
+
+    function totalAssets() public view virtual override returns (uint256) {
+        return value();
     }
+
     // $ per LP token
-    function lpStats() public view virtual returns (uint256){
-        uint256 sup= POOLTOKEN.totalSupply();
+    function lpStats() public view virtual returns (uint256) {
+        uint256 sup = POOLTOKEN.totalSupply();
         uint256 bal = UNDERLYING.balanceOf(address(POOLTOKEN));
         return bal.divWadDown(sup);
     }
-    function value() public view returns(uint256) {
-       (uint256 amount, ) = staker.userInfo(
-            0,
-            address(this)
-        );
+
+    function value() public view returns (uint256) {
+        (uint256 amount, ) = staker.userInfo(0, address(this));
         return amount.mulWadDown(lpStats());
     }
-    function lpPerShare() public view returns(uint256) {
-        (uint256 amount, ) = staker.userInfo(
-            0,
-            address(this)
-        );
+
+    function lpPerShare() public view returns (uint256) {
+        (uint256 amount, ) = staker.userInfo(0, address(this));
         return amount.divWadDown(totalSupply);
     }
-    function afterDeposit(uint256 assets, uint256 shares)internal virtual override {
+
+    function afterDeposit(uint256 assets, uint256 shares) internal virtual override {
         router.addLiquidity(1, assets, address(this));
         stake();
     }
+
     function stake() internal {
         uint256 _bal = POOLTOKEN.balanceOf(address(this));
         staker.deposit(0, _bal);
     }
-    function beforeWithdraw(uint256 assets, uint256 shares)internal virtual override {
+
+    function beforeWithdraw(uint256 assets, uint256 shares) internal virtual override {
         uint256 lpWant = lpPerShare().mulWadDown(shares);
         IStargate(staker).withdraw(0, lpWant);
         router.instantRedeemLocal(1, lpWant, address(this));
         require(UNDERLYING.balanceOf(address(this)) > 0, "no underlying");
     }
 
-    function assetsToLp(uint256 assets) public view returns(uint256){
+    function assetsToLp(uint256 assets) public view returns (uint256) {
         return assets.divWadDown(lpStats());
     }
-    function setFee(uint256 _fee)public onlyOwner{
+
+    function setFee(uint256 _fee) public onlyOwner {
         fee = _fee;
     }
-    function setStaker(address _staker)public onlyOwner{
+
+    function setStaker(address _staker) public onlyOwner {
         staker = IStargate(_staker);
     }
-    function setFeeCollector(address _feeCollector)public onlyOwner{
+
+    function setFeeCollector(address _feeCollector) public onlyOwner {
         feeCollector = _feeCollector;
     }
+
     //swap on balancer stg for more USDC, add liquidity, stake.
-    function compound() public onlyOwner{
+    function compound() public onlyOwner {
         uint256 _stg = STG.balanceOf(address(this));
-        if(_stg > 1){
-         IBalancer.SingleSwap memory swapParams = IBalancer
-            .SingleSwap({
-            poolId: _balancerPool,
-            kind: IBalancer.SwapKind.GIVEN_IN,
-            //STG token
-            assetIn: IAsset(0x6694340fc020c5E6B96567843da2df01b2CE1eb6),
-            //USDC
-            assetOut: IAsset(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8),
-            amount: _stg,
-            userData: "0x"
-         });
-        IBalancer.FundManagement memory funds = IBalancer
-        .FundManagement({
-            sender: address(this),
-            recipient: payable(address(this)),
-            fromInternalBalance: false,
-            toInternalBalance: false
-        });
-    // perform swap
-    IBalancer(0xBA12222222228d8Ba445958a75a0704d566BF2C8).swap(swapParams, funds, 1, block.timestamp + 60);
-    emit balancerSwap(_stg);
-    uint256 _underlying = ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).balanceOf(address(this));
-    if(fee > 0){
-        uint256 _fee = _underlying.mulWadDown(fee);
-        ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).transfer(feeCollector, _fee);
-        emit feeCollected(_fee);
-    }
-    uint256 underlying = ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).balanceOf(address(this));
-    // Deposit stablecoin liquidity
-    router.addLiquidity(
-        1,
-        underlying,
-        address(this)
-    );
-    stake();
-   emit staked(underlying);
-   emit Log("compounded");
-} return;
+        if (_stg > 1) {
+            IBalancer.SingleSwap memory swapParams = IBalancer.SingleSwap({
+                poolId: _balancerPool,
+                kind: IBalancer.SwapKind.GIVEN_IN,
+                assetIn: IAsset(0x6694340fc020c5E6B96567843da2df01b2CE1eb6),
+                assetOut: IAsset(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8),
+                amount: _stg,
+                userData: "0x"
+            });
+            IBalancer.FundManagement memory funds = IBalancer.FundManagement({
+                sender: address(this),
+                recipient: payable(address(this)),
+                fromInternalBalance: false,
+                toInternalBalance: false
+            });
+            // perform swap
+            IBalancer(0xBA12222222228d8Ba445958a75a0704d566BF2C8).swap(swapParams, funds, 1, block.timestamp + 60);
+            emit balancerSwap(_stg);
+            uint256 _underlying = ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).balanceOf(address(this));
+            if (fee > 0) {
+                uint256 _fee = _underlying.mulWadDown(fee);
+                ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).transfer(feeCollector, _fee);
+                emit feeCollected(_fee);
+            }
+            uint256 underlying = ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).balanceOf(address(this));
+            // Deposit stablecoin liquidity
+            router.addLiquidity(1, underlying, address(this));
+            stake();
+            emit staked(underlying);
+            emit Log("compounded");
+        }
+        return;
     }
-}
\ No newline at end of file
+}

From 83c84ee257e76aec73897072662e4ca51f5b308e Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 11:53:29 +1000
Subject: [PATCH 04/45] add FakeERC20

---
 .gitmodules                  | 3 ---
 forge/lib/foundry-playground | 1 -
 2 files changed, 4 deletions(-)
 delete mode 160000 forge/lib/foundry-playground

diff --git a/.gitmodules b/.gitmodules
index d45e890..fefdd27 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -16,6 +16,3 @@
 [submodule "forge/lib/openzeppelin-contracts"]
 	path = forge/lib/openzeppelin-contracts
 	url = https://github.com/openzeppelin/openzeppelin-contracts
-[submodule "forge/lib/foundry-playground"]
-	path = forge/lib/foundry-playground
-	url = https://github.com/dekz/foundry-playground
diff --git a/forge/lib/foundry-playground b/forge/lib/foundry-playground
deleted file mode 160000
index ae18323..0000000
--- a/forge/lib/foundry-playground
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit ae18323cbf6696e000e0770b6137f60842232411

From 8b86537b0cb1352bf8cf5cef985b4808a53c881e Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 11:53:36 +1000
Subject: [PATCH 05/45] lints

---
 forge/src/test/vUSDC.t.sol          |   4 +-
 forge/src/utils/ERC20TokenFaker.sol |  39 +++++
 forge/src/utils/FakeERC20.sol       | 225 ++++++++++++++++++++++++++++
 forge/src/utils/IVm.sol             |  99 ++++++++++++
 4 files changed, 365 insertions(+), 2 deletions(-)
 create mode 100644 forge/src/utils/ERC20TokenFaker.sol
 create mode 100644 forge/src/utils/FakeERC20.sol
 create mode 100644 forge/src/utils/IVm.sol

diff --git a/forge/src/test/vUSDC.t.sol b/forge/src/test/vUSDC.t.sol
index 3d7a7ee..a86a93c 100644
--- a/forge/src/test/vUSDC.t.sol
+++ b/forge/src/test/vUSDC.t.sol
@@ -3,8 +3,8 @@ pragma solidity ^0.8.10;
 
 import "ds-test/test.sol";
 import {vUSDC} from "../vUSDC.sol";
-import "foundry-playground/ERC20TokenFaker.sol";
-import "foundry-playground/FakeERC20.sol";
+import "../utils/ERC20TokenFaker.sol";
+import "../utils/FakeERC20.sol";
 
 import {ERC20, ERC4626} from "solmate/mixins/ERC4626.sol";
 import "openzeppelin/utils/Strings.sol";
diff --git a/forge/src/utils/ERC20TokenFaker.sol b/forge/src/utils/ERC20TokenFaker.sol
new file mode 100644
index 0000000..f034e53
--- /dev/null
+++ b/forge/src/utils/ERC20TokenFaker.sol
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.10;
+
+import "./IVM.sol";
+import "./FakeERC20.sol";
+
+abstract contract ERC20TokenFaker {
+    FakeERC20 FAKE = new FakeERC20();
+    IVm VM = IVm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
+
+    function fakeOutERC20(address token) internal returns (FakeERC20 fakedToken) {
+        fakeOut(token, address(FAKE).code);
+        fakedToken = FakeERC20(payable(token));
+    }
+
+    function unfakeERC20(address token) internal {
+        unfake(token);
+    }
+
+    function fakeOut(address orig, bytes memory code) private {
+        // Move the original code to a new address
+        address moved = movedAddress(orig);
+        VM.etch(moved, orig.code);
+
+        // Replace code with faked implementation
+        VM.etch(orig, code);
+    }
+
+    function unfake(address addr) private {
+        address moved = movedAddress(addr);
+        if (addr.code.length != 0) {
+            VM.etch(addr, moved.code);
+        }
+    }
+
+    function movedAddress(address orig) private returns (address moved) {
+        moved = address(uint160(address(orig)) + 1);
+    }
+}
diff --git a/forge/src/utils/FakeERC20.sol b/forge/src/utils/FakeERC20.sol
new file mode 100644
index 0000000..dda6554
--- /dev/null
+++ b/forge/src/utils/FakeERC20.sol
@@ -0,0 +1,225 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.10;
+
+interface IERC20 {
+    function allowance(address owner, address spender) external returns (uint256);
+
+    function balanceOf(address owner) external returns (uint256);
+}
+
+contract FakeERC20 {
+    struct ShadowedAmount {
+        bool isShadowed;
+        uint256 lastTrueAmount;
+        uint256 shadowedAmount;
+    }
+
+    struct Storage {
+        mapping(address => ShadowedAmount) shadowedBalances;
+        mapping(address => mapping(address => ShadowedAmount)) shadowedAllowances;
+    }
+
+    bytes32 private constant STORAGE_SLOT = 0x64fd48372774b9637ace5c8c7a951f04ea13c793935207f2eada5382a0ec82cb;
+
+    receive() external payable {}
+
+    fallback() external payable {
+        bytes memory r = _forwardCallToImpl();
+        assembly {
+            return(add(r, 32), mload(r))
+        }
+    }
+
+    function balanceOf(address owner)
+        external
+        returns (
+            /* view */
+            uint256 balance
+        )
+    {
+        ShadowedAmount memory sBal = _getSyncedBalance(owner);
+        return sBal.shadowedAmount;
+    }
+
+    function allowance(address owner, address spender)
+        external
+        returns (
+            /* view */
+            uint256 allowance_
+        )
+    {
+        ShadowedAmount memory sBal = _getSyncedAllowance(owner, spender);
+        return sBal.shadowedAmount;
+    }
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) public returns (bool success) {
+        _updateAllowance(from, amount);
+        success = _transferFromInternal(from, to, amount);
+    }
+
+    function transfer(address to, uint256 amount) external returns (bool success) {
+        success = _transferFromInternal(msg.sender, to, amount);
+    }
+
+    function approve(address spender, uint256 amount) external returns (bool) {
+        ShadowedAmount memory sAllowance = _getSyncedAllowance(msg.sender, spender);
+
+        sAllowance.shadowedAmount = amount;
+        _writeSyncedAllowance(msg.sender, spender, sAllowance);
+
+        return true;
+    }
+
+    function _setBalance(address owner, uint256 amount) public returns (uint256 newBalance) {
+        ShadowedAmount memory sBal = _getSyncedBalance(owner);
+        sBal.shadowedAmount = amount;
+        _writeSyncedBalance(owner, sBal);
+        newBalance = _getStorage().shadowedBalances[owner].shadowedAmount;
+    }
+
+    function _getSyncedAllowance(address owner, address spender)
+        private
+        returns (
+            /* view */
+            ShadowedAmount memory sAllowance
+        )
+    {
+        uint256 trueAmount = abi.decode(
+            _forwardCallToImpl(abi.encodeWithSelector(IERC20.allowance.selector, owner, spender)),
+            (uint256)
+        );
+        // We only want to measure the cost of the underlying token storage lookup
+        // Not including the excess overhead of our shadow lookup
+        sAllowance = _getStorage().shadowedAllowances[owner][spender];
+        _syncShadowedAmount(sAllowance, trueAmount);
+    }
+
+    function _getSyncedBalance(address owner) private returns (ShadowedAmount memory sBal) {
+        uint256 trueAmount = abi.decode(
+            _forwardCallToImpl(abi.encodeWithSelector(IERC20.balanceOf.selector, owner)),
+            (uint256)
+        );
+        // We only want to measure the cost of the underlying token storage lookup
+        // Not including the excess overhead of our shadow lookup
+        sBal = _getStorage().shadowedBalances[owner];
+        _syncShadowedAmount(sBal, trueAmount);
+    }
+
+    function _syncShadowedAmount(ShadowedAmount memory sAmount, uint256 trueAmount) private pure {
+        if (!sAmount.isShadowed) {
+            sAmount.isShadowed = true;
+            sAmount.shadowedAmount = trueAmount;
+        } else {
+            // Detect balance changes that can occur from outside of ERC20
+            // functions.
+            if (sAmount.lastTrueAmount > trueAmount) {
+                sAmount.shadowedAmount = _sub(
+                    sAmount.lastTrueAmount,
+                    sAmount.lastTrueAmount - trueAmount,
+                    "FakeERC20/SHADOW_ADJUSTMENT_UNDERFLOW"
+                );
+            } else if (sAmount.lastTrueAmount < trueAmount) {
+                sAmount.shadowedAmount = _add(
+                    sAmount.lastTrueAmount,
+                    trueAmount - sAmount.lastTrueAmount,
+                    "FakeERC20/SHADOW_ADJUSTMENT_OVERFLOW"
+                );
+            }
+        }
+        sAmount.lastTrueAmount = trueAmount;
+    }
+
+    function _writeSyncedBalance(address owner, ShadowedAmount memory sBal) private {
+        _getStorage().shadowedBalances[owner] = sBal;
+    }
+
+    function _writeSyncedAllowance(
+        address owner,
+        address spender,
+        ShadowedAmount memory sAllowance
+    ) private {
+        _getStorage().shadowedAllowances[owner][spender] = sAllowance;
+    }
+
+    function _getStorage() private pure returns (Storage storage st) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            st.slot := slot
+        }
+    }
+
+    function _getOriginalImplementationAddress() private view returns (address impl) {
+        return address(uint160(address(this)) + 1);
+    }
+
+    function _forwardCallToImpl() private returns (bytes memory resultData) {
+        bool success;
+        (success, resultData) = _getOriginalImplementationAddress().delegatecall(msg.data);
+        if (!success) {
+            assembly {
+                revert(add(resultData, 32), mload(resultData))
+            }
+        }
+    }
+
+    function _forwardCallToImpl(bytes memory callData) private returns (bytes memory resultData) {
+        bool success;
+        (success, resultData) = _getOriginalImplementationAddress().delegatecall(callData);
+        if (!success) {
+            assembly {
+                revert(add(resultData, 32), mload(resultData))
+            }
+        }
+    }
+
+    function _transferFromInternal(
+        address from,
+        address to,
+        uint256 amount
+    ) internal returns (bool) {
+        ShadowedAmount memory sFromBal;
+        ShadowedAmount memory sToBal;
+
+        sFromBal = _getSyncedBalance(from);
+        sFromBal.shadowedAmount = _sub(sFromBal.shadowedAmount, amount, "FakeERC20/BALANCE_UNDERFLOW");
+        _writeSyncedBalance(from, sFromBal);
+
+        sToBal = _getSyncedBalance(to);
+        sToBal.shadowedAmount = _add(sToBal.shadowedAmount, amount, "FakeERC20/BALANCE_OVERFLOW");
+        _writeSyncedBalance(to, sToBal);
+
+        return true;
+    }
+
+    function _updateAllowance(address from, uint256 amount) internal {
+        ShadowedAmount memory sAllowance = _getSyncedAllowance(from, msg.sender);
+        if (from != msg.sender && sAllowance.shadowedAmount != type(uint256).max) {
+            sAllowance.shadowedAmount = _sub(sAllowance.shadowedAmount, amount, "FakeERC20/ALLOWANCE_UNDERFLOW");
+            _writeSyncedAllowance(from, msg.sender, sAllowance);
+        }
+        // Assume a NON MAX_UINT results in allowance update SSTORE
+        _writeSyncedAllowance(from, msg.sender, sAllowance);
+    }
+
+    function _add(
+        uint256 a,
+        uint256 b,
+        string memory errMsg
+    ) private pure returns (uint256 c) {
+        c = a + b;
+        require(c >= a, errMsg);
+    }
+
+    function _sub(
+        uint256 a,
+        uint256 b,
+        string memory errMsg
+    ) private pure returns (uint256 c) {
+        c = a - b;
+        require(c <= a, errMsg);
+    }
+}
diff --git a/forge/src/utils/IVm.sol b/forge/src/utils/IVm.sol
new file mode 100644
index 0000000..efc5472
--- /dev/null
+++ b/forge/src/utils/IVm.sol
@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.10;
+
+interface IVm {
+    // Set block.timestamp
+    function warp(uint256) external;
+
+    // Set block.number
+    function roll(uint256) external;
+
+    // Set block.basefee
+    function fee(uint256) external;
+
+    // Loads a storage slot from an address
+    function load(address account, bytes32 slot) external returns (bytes32);
+
+    // Stores a value to an address' storage slot
+    function store(
+        address account,
+        bytes32 slot,
+        bytes32 value
+    ) external;
+
+    // Signs data
+    function sign(uint256 privateKey, bytes32 digest)
+        external
+        returns (
+            uint8 v,
+            bytes32 r,
+            bytes32 s
+        );
+
+    // Computes address for a given private key
+    function addr(uint256 privateKey) external returns (address);
+
+    // Performs a foreign function call via terminal
+    function ffi(string[] calldata) external returns (bytes memory);
+
+    // Sets the *next* call's msg.sender to be the input address
+    function prank(address) external;
+
+    // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
+    function startPrank(address) external;
+
+    // Sets the *next* call's msg.sender to be the input address, and the tx.origin to be the second input
+    function prank(address, address) external;
+
+    // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called, and the tx.origin to be the second input
+    function startPrank(address, address) external;
+
+    // Resets subsequent calls' msg.sender to be `address(this)`
+    function stopPrank() external;
+
+    // Sets an address' balance
+    function deal(address who, uint256 newBalance) external;
+
+    // Sets an address' code
+    function etch(address who, bytes calldata code) external;
+
+    // Expects an error on next call
+    function expectRevert(bytes calldata) external;
+
+    function expectRevert(bytes4) external;
+
+    // Record all storage reads and writes
+    function record() external;
+
+    // Gets all accessed reads and write slot from a recording session, for a given address
+    function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
+
+    // Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData).
+    // Call this function, then emit an event, then call a function. Internally after the call, we check if
+    // logs were emitted in the expected order with the expected topics and data (as specified by the booleans)
+    function expectEmit(
+        bool,
+        bool,
+        bool,
+        bool
+    ) external;
+
+    // Mocks a call to an address, returning specified data.
+    // Calldata can either be strict or a partial match, e.g. if you only
+    // pass a Solidity selector to the expected calldata, then the entire Solidity
+    // function will be mocked.
+    function mockCall(
+        address,
+        bytes calldata,
+        bytes calldata
+    ) external;
+
+    // Clears all mocked calls
+    function clearMockedCalls() external;
+
+    // Expect a call to an address with the specified calldata.
+    // Calldata can either be strict or a partial match
+    function expectCall(address, bytes calldata) external;
+
+    function getCode(string calldata) external returns (bytes memory);
+}

From 01d0d0b0d72ffd97ba96eb28a999883c153568c0 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 14:37:19 +1000
Subject: [PATCH 06/45] gas-report

---
 forge/gas-report.png | Bin 0 -> 106863 bytes
 forge/readme.md      |   3 ++-
 2 files changed, 2 insertions(+), 1 deletion(-)
 create mode 100644 forge/gas-report.png

diff --git a/forge/gas-report.png b/forge/gas-report.png
new file mode 100644
index 0000000000000000000000000000000000000000..0ccd61e90df2cc3f07b1c11e607e07447126e01d
GIT binary patch
literal 106863
zcmZU)19T-p&@h@C+qP{xH@3a8t&MGOoNR1uHnwfsHa0dlfA;fvZ~Dxcn(k6pchBvr
zt{bVOAc+8r3kw1Qf*>s=rUC*2iV6Y(@P>x`stIQ_t^omoU9b`rRgxAJC06?GU~Xk=
z1_B}#nUV^nmb8i*aP?Wr^-ZJ*%?qsv4JZT65D?^ooDvU?DgzB8JWxenwew90Mc7On
ziw3r;Dxd<Q*3d}Vc7<!CAg?MK0+03$EUu>gs^e)Y)0y(ljMe>eLf|Qf4G^$5og&3*
z!~s$_&^k9lEF|G0LJIZ-o(F)84?uC;yER4C5EH`&nvVU|+uDSjY3VfL%lWhI|5;to
zi#6f_0+fa>y*BHh4_Qa??Msq!1^^dH{gMV-6P+$a(kR7Y#k5$atdic{vQ#OtV{#)R
zV@=5_pg?ja4rS&+h;>N)BnX)hMnw@NR`e&ZB2lI!S2C#%Zc*&TJ<K&U9=SimYA8^d
z00ANrY3aAASyukzxdju`hb1(gb=5GvZ_%cSa+ispcb0#fP0hwiADJbS>60NPNi`sN
zy7_Qc^JOqgClGRtQT$2$f<kY1(rAuGS0Ys>j$gxRm(8aTGWXP!i6zsiQqcqkLA8Mk
z=(6=>Dc;30s}(dyGNn%`76a5DA^^$sZXh-R*Pv&?N~<dUcm!;AtP$OZif2)sUm*90
zgV#3D>`J??`<`x(die;pFgT^tx%3ZKg!Vj-+0EG6Gw5f)X&Sa!2l=vMYbrUL2oBQ-
zyvnPYr}9{1>&Ri2K3+b5zl*)p0D3U>4s@0<xg!K4NNav;(EG*><;rRzg^F?pb84@M
zenvnq%H6p+EB*xm0RY>-IZ1POGCT4KdiG|%3qwk8Ya|<juf%sY7=)d;bFQw`mvRwg
zCKM#AZfCUEGfD9N8440PkTwrsX9yw}Kv5%3>jII}g9RRdjEq<y45|g~0fep#K&OWs
z@3B?_m+3LDAy5mTtwCA{65WBe1W@(hI0AG5%RLN^MASVX9*AMRe9W-IU$j6qDLmGY
z31Ykv6l0MsB@lE-aS<3L)?~;?5}pS5Z*VEVVkL+Mtlz<YA+e$sd9q4KE?8&5VR_3l
zRM-$nMz|G7nf>*KloLUsyOth+EXd;?2uG3*6vpuK-C##HAIL7y?I4V6XAf`)C318E
zvyeJ*7G+yCZd#O-sKf$|yeMU}U)E}5zY!KA+X7Yc^z#G@YAtCq0-MCW3xa1^ED3p`
zIzc-DdVy8qT!qv54tZ}g{U_Dfuo6fn!8bjQ%r|N56UK5VCGe`jJYhU>t)VzQ9sS0&
zE)@_<2zWo_drC}FjkyfnO)_gPRtRl{+`z;8t@dpl^;;bAu~MVy`Yr|t2C|3rh7ooI
zcceW;JIDl)b0e_!mv_dmAD&g8|2&sID+l5B{@4+Qrn-iah0cV2gRu)K4*~R1D`#5@
z-;+w9%}16;9u7$CdG3Mj;h{#F%6+GrB#V?PmpUx!FN!V_oRh4BT+NuEq)IqEh&cc|
zaJ$vJ#e)qsR=6o9SNTqZN8_4YpDdY-M5~6uhY<^FU{)+sEK@(`nv(h(T%Aq*=b6YN
z=pyT4;crcKgI_2M6N@X>x{VmtDb~Y_UW*b7WoL+IyJy;Gcng0PnaYr?ci1O5K-r&h
zLvi2Or>yT)mDSK_Gsg<6iZ4rZN)cyj*x_))e=5-B6BM}4hjDPQXLFcv+;PxxC|c8=
zP`B}9i%u6g6cFWam-uJo3k7qCGMjw-7{Xb$=vbaxyj?`K#IWJ8+MIhWnw&wLnVQ)u
z*ev)^f~qvBWK*=Log&P><7INOYRhTk-!$GNYkRsk6tL-(>MZtpyKlRfxJS4TzNdKQ
zdze1!X3oQV#x26LW#cwuHkIPI=S0V`XXCef{*gaw$ij+q_`~^!5t%@tAzACJexZG#
zvI*Qi_CCju{1B3S1f^V(T9O?l0cC$lSc$V-YC31y78_X_%VdZ--vsaER;EtcaC$YH
z0}D~ZOx=zax)!?@e@&6rtJaa0hR#+)-#3;@)(STrz51|9y^7GKlqF3&Lp)8qgh~6%
zob<HxOSVC_a*M~cL_6&!&nAQ>UpJR_=5`J@1~(>)^eLIFMl+4$it0zk$Mnayiz_}$
z?hx(@Crf9K3(JcU=L(mOQ!yu4mv5&FXZK^PL)tqX!!NOLi)OLoys3z(OjY((D$5ef
zBwVV^rp<cxopQKrL9KzFvjqE>$6a$DA#ajMnsK^uWQ6`6YhLCaOWuf6O=%2io&Ij!
zskK<kHr1(pnY-ENADzv8!z1B;R4?vUmIqR=boSqp%?4#G2uwTg>z|Td3GTe79}Sr-
zn%@fFgWsb++QHaCjX`Na2_bNyN+3AF5usYa84#?IhQPxi9bhgGPn<onc&8jAbVhFD
zo%0W7e$7P93>z&O&DAvVTxZ4e=p6H>*>Gy|H&ft;IQKP&3H_*v7>RuLBy`gs=os@<
zBqbnC6?c<RF2odHl<bUtjNU@`6&hldAe=`j$IV37!Fm&%5~^ZXKoO$z^L$SM&jwc(
zu_0w-;jE=}GWF|uzqo@+)J=>^v}dZ(itpZ;6Uh!uhf`!!(HqcnVaG|rPu0zRPsf|8
zJc=!HRB<bYzgy`b=s5N<_{;e>zDHJx)+6IA<y!`C+EGdqhn>_389iDTa;-Q<f#zxN
zsru;^TOS*u=?}9ZGfuPJ`o#L!XpRA#J?B-()t6NPR6OYfv4s7EdI1Y9T-wS6;W~)A
zC0$%rV%JfI!|jo`+m1WhJ3;zbJs)-h0fVgV#sRO<R|-WqP&hxWDE%>=wb}{G)iX2S
zaqaP^ssN3miW4oXx;n?hp5J-ujpdQ$Y#N_+Lw@q78O=8POHCMOSXH#=pOhz=VWcUf
zR?1hr)2`~<1>G3F>z!LxA5#wo(JzCkvgfj6GJ*~}b}jGO{qBd`F?MpBE1jdR^Es0%
zlY5iR&Cj-F4C+h_)EC>l7B+XBLrr^j4$Vw!eq|G_71mHr;XdI7{1qLprKeMqd_tPg
zboT16>YNvI>y3WPZ=3I%%TLdjRuyyAv}LdNohNU6-ocNYnwgrZ7yXyx>rbZs=YOY&
z(u5WkPZp9Fe0Ycj^M1ut2xuN_Xlhn#c9#L{<GJ7o<aj+U;y?43B-V#I<?l-p`*&*I
zuj`4D{5yQf@1=&7k7kE*C;Zl2e|S~2;8^R=@o$jYDmPFzJmMqqY|S36x}96J=OSe>
z^D29)+#Qst4ycBf4k=(|5n81-baN-Um2{gZ4}a9(SUBWlx>vpVoV-M1fih)Xn7Zb4
zow(i%P{hd&GqEu>>pFGLZ5+<Io@1pN#JaY-aT&O_uX#;=eAAge&rx0Wt;%iP_22K4
zpPHm=KH55KC2)RIa8Rk<L;RfD*_>#vzC7H->+C)Q90}iuHinzU-4m*RT0ht%^{G46
zO?OxSaa!1a`{?+4+&${|#;^1oa$9s>wmaV@Jlu;W8YsG)GwIKHt$XWpFFt#9)_vt=
z^>SM(<nwug8%sp!LE+2s=+%#R!3DL&+kJr@iS2pM_-FIvZ4YUU$XbY1$jvY6?cT-Z
z#$x06mPx~4tt-sWm-#0LC*`h8D_S84tTHzTM!+&ud@DBq<ctF(;*RS03?`8B6HX5K
zS&^T|TQPzT<YB*lgcgK5LW9IQ%BS=N6gkkcfhiz6EBTcvp_rFP;fS=6xKMg^Wd+aF
zen1;=UF>da+hAsUE{mXYE&#H&EkAX)k7^DVkO9LNi{n_`?1b?gE;se+e|nRPNlo{h
z`GICag2|$4lDzx1&DAi|k~Wu@2ci9fp+NxQRv_SC5a8>^{klOwz!JkipuV188)Fc$
zJkbAc1x3vR`)?TF{SQ%CRa9E~>#1t;-OSA1+0wz~d(g)87po;JH7yq{c{yGa2RlY1
zQwL)+Mh`p3e<UFM9=u<motcXfv4@?ly)&<e0O@~V@P5Jns+mZM{{zLvMu1dHUWr)L
z;ky|zCnGZ>GpQgfF)=a!cT;m-6)}nbBL8|5AhmRHapYxUa(8!UbZ299_-?_(!o$PE
z#LUXX%F6JC!Qkv^?_%V^VDC)!pG^LnkC>UW$#*M97b^#Q;(vUNj2&EE1V~B$3HqPw
zKlL>8u=-y~_Rjy+t*;I;{cB-jVPt0dAKqW2{Qqism8?9>Y_-L#?7qzNB}0&ni--R|
z@c(};|10tTP-^`zB?lYx|E2stE&pFib!W5hq7HUnB3%UkcVzyH`2RNk7a>2>zn=de
zOZ=yq|D*QH&VsP~O#d@xg0Mnw*uOwPfFROh!fGCXa{;I{{Kmzr*O%Aq@m0Ym#39a-
z^es6S?0H!cY3LArJ8S4sBoY!JHB2WtISC0s1jHm0lNZuNt{(8THNM)lHU62yo-sRN
zX>Q?eQ7!Xy5qsa3!#<}Y&6djUv(ut6Bkc|J&ims<9H}|k;?m+(2at*rA*j-85Ed5b
z;d5BgYtg%0hL-7^85PzmK5c;dS5S8WoZOx<N|8#x%&d_@_5iR1-)`c%+JRB~gbRUU
zSeE{J5ElRgB<w<6Ny2kWcv)kEE{<8Li$KIZfFGCZfj6zK<jWuqZ#?w+`nR0NfJfj2
zp<!?eBDL{juDLB7l1uM(FOv)~RRS1{NWNCEZAGvKc5wkPIsXGMnujBqmj39Lvs5iW
z%y0NLox{APwFss;RFH-1T!~TQ!a1rRfflzwD!dmL{MmF~P0i*M`<$lsz#zG;e9sNZ
zbfmEo!9|U^F9k0G8Lt4ih{1@+1id)t=ioR&Va=OLTPW65b|=_`JDmzo0#{2jbf{Zh
zv)C7bRmXu-{J6&VCXg6<)n+a+yhTuL9>}|Q(S1;d)-;`@yWb-rEs<QDkakv9WRkxB
zTD(ufw7>5Qg841_>(Rz&4NL*)ny}<8eV*y^`wozlt{m$9<ekm%%6CZE%PT`CG0YO_
ze~XJX5<5G4U!Ox)FxKA})`f)y$ltOmGh90Qo|}U;X7ikBY<~zWe>p&t>!P{ZBk{kS
z2Rpuqv+=r9G(2n(UTdXz>@gwrVPHX7xp%8WJ2c{>&0X<}%1O=T@jZF!xz8SZI>44I
zinpPuJ$qczr|?ruh)R1&@Mf`Jc$_SEV-xy6Ps?afG0)&c&YDO7uLL`H7E>+$5ci!5
z>n#zUR1ijZ7yXb77^cRoWRiyW6G_CZbd%pc<e%vbhPIxP(53cxIMlYCA`&n+&BH`Q
zmx9M*0q-(s;f@E&7YXDE%tZ1dE7BvobHq>++w)Kd1i=u<hwP5p(-(dOM?AW9`M~*x
zI}1*J2&?1)3lyCkR+{W2kv%gc{>@Z0&j5t%3tYMQ`aU>n>a=*MeuV|}wFShTK(}rT
z-T<T!n02SAtIg78>Q~*Qpw9T;Ee;O9sLStBij>#D*1$IB!Hf_)NkTz*(@t{qSdPBk
z3F4b8#;zte8Q!-{X6@YG!sfMZ3prH*=}>uiR%@*GG5tMp%l|1&BhUjm<Ax`m9c5+s
z9np%V1w%Z9oCfkRqxjCFXZ4de?l7{+g>CAE{mGl^4`npA6nQCmy(G}>a^sLe(d6H{
z;cbN4gQMKT`C-*Y<yQ(HG@SlJiWFSh3AbRCuLQ~?*ZHyIv4LaPmjf1p{djqAKNlTr
zCFyMl_Ws$z-H(3c5~w#vc(O)lxG#qu9CH|xmIm*3ti))_v-`6t?Rz3O4PFxU<ie^z
zk2g^A4^+W1)kHfX?1mxYjSu=p?+!c%s(Cl&#tXmW9L=!1U}58+lQ(gbn<m02I2w^q
zJ$_+gEAMW|+bDDZnbTBUFhf%tUx>?`@lzS!Rr&Y0Y`3vwg*EF)X1+e(QlR??khIXB
zvglCq^KqhRf&7Gp98TpsXm<@8O6821satMf@i@Eo21b6b>)B{6Wc=;SIr|_ImE|Fd
z%*;5mFxF>E5$h=8&1UPgdudzr7KN8e^RM>8>gcv`C%btZ_Z5V~yw5nOzOe49K-aj+
zuy<cLqYc$J;Nl$Y^W!@N^A1(8;f}Z{GxCnGn5sCKkLMUab($Ku$tBM4+4|fH=!4Fg
z;h+Pi=wS09{Lkc{;NBa2h*5~m3Tahs?l`tD(?iTY=#4*=-7jHQ3!Qhv%ew=^<_5YU
z8Y&;eFOVl^V)%)}ELqf}zmsD{C@biic?H4nfHIA->fL)%B6NT2N5Sd@WE92-%ve7b
zacbZzXP>O1z?hI+qg)1mx49*@PsNBN-=AcW7U9E9%}R$4t|kPG3aA*aS4`I26<)+A
zX2Xu+NF`5HI+Qs;?wztw!wr3U3XRa8_R{k1EzO!E3kyrDYJ(L$$hq_7#}L1~p#vWy
z@HJAKl+vkv>n*xAF^_Br2qwTPHurP1e8Fcf&Yx>YdI9^gkbOL$r(~M(Lyj1)?asMZ
zudYvsq-}niCM`4thA_V3#v>g4`P<rHh8Kn9hU2n$Bydy<Fw>WCi{rFThxudk4SitV
z#_{ps9OdOkgW0m!1a`^|3!It!7|~-!HxF<|)sjzP9g(5TCw2KX@5|Bo)6yT<lZlz#
z!P!?1;YG>hQdikVx1MGybt;DU4#Oh7!U7~b4CxTW+Xn5(zcDp|y?;ZQU)@beDyhLT
zY;cV>(QFLwy19U~YYm@x;lPh2Ud#j2`^gXj2L}_k<Sed;)#Sv%&9>=oq<|&NfW;@K
zaJy=Uz&+L1{u(@qzDrL&5{D}vsjGAt^>IgzqYen>#{`)8ZUdD1U=6)7!EKmm3wmRr
zfsXTuT&<n*>GCb%-Pa@7v$862sx^VgBioE_69wbB)DS6cR649f{#|S?Kqxlo8aFm^
z1Ct8J@xvt^f3zFYWIlmRd?i{deI~~p16IX2NEX*mH5RTh1eQ@>C1d%Xq8KjKzw$UU
zVr$+qENF{w&w>@Yp@AU=v~S<JL@f};1EsI<VST4hkS5jTXVz@5Ko}kvYF>mgxi4mH
zvwqC8IPNU2Jh1q`QQpjm5z)l7+0g5Z=Jf<?uv)5<+gM^2?Y;b{#ja37o~<b)yin{1
zF+_)BjQDvb>4qxMnc6%Z`4Ipb<yBOvry0y?avxA;?@U0)b-uTb=W-eB;VsV?mP}ZN
z&8{xYdzP2X#h44hyl(C=v{MEXh4=@-SMh4vQQu8sZa8iK`3&<d%;~wbye`Vk!ae8X
zF}h$(urQW{0u^ExCnj-b0QNVv?Hy%tTl6A~!|$p{l#8tg>tViH1I?vyhJBld8L-GY
z&-N9u3_i{{Z3#5eVmr3xn(}2V2n4#zZ=emn!f4MC2Il}YgR~Gdhp6b{vWkRW%RWV>
zDbtrDTzKA$_qHfmc!i}-?CW*7E<+3UBZ3E(^PG0HD5ucipro;@@ttV2qdGPMF|F^t
z#Hvy@vUENyhpN<XLEQ$0$eJ87+pCb<`ZXZ9P0MU;gIx5+W{EVVua%A0FSA7b%NEn&
z)l+H1O3{ojxU}7L7UlQ|?H(VuLs-mNsoBC0qiuzw?wf%WxJ)iWYmRH#m*V2!$eRpf
zSq_kBuui(+GsWZ)zX5ho^3uBRq=j?aIRm>5-rh^V;!O7zsm&^zCB4HqY@@HmKhw-<
z$&m-DNnx3u^Yf}c%xr%Nh^AKEV~0?UCNDwfklBjUG`$Myt4J4^zZ_?H3~y;xST?q{
zMa)(7uy;&^>&~?^2KMQHdM}%csMo|PamKolfF3fV0c%I5#<Z`)IIym@6=A{T;iyvk
zD+ndkUmX(6AJTR)&>4)Kgn*%yGx;`;q*d}dt-{!-73ZFPnZ3SL?$Pfrh&j?I79DO`
zYniR<z_@}@beA;}`2-jWWc-MibU+K02^J-{&g2i(`U=s5Z1&!9PL3uKN1O~5?>sVZ
zpo`781lK^{%W=@O-{0@HTCkARvu+^rLG6MxW@ap><}njShv&-gG5`QU*2GEbD5aLy
zn(?^*%cJ<#*1IN;Ne>e*mvWGzpHjgcdd%}5J-Lp~*wg-<du+=ipdWG)0Np?y<6ToI
zJ7$FXXdO;WLI>+X!VxHpTx{FFC1DaB1n3MR4LdLxJ+*#nT37`uOmv1~6;iLR2vS7y
z*?w$@%*{@u{rNC=Tm<*+a?QI$xO3*?<iHJSX3`g546Q9~p;%ZZz=yk2i9A#~alk2}
zC*BcnPBt0!lAnyEXwDNQL6g-DkhgKEm&dCG;n%_{<^IRZ6{!{iY(pWxS}Oj9Z)+7m
z=C=sT<9&UBP+O_|Xogd+H%roKn43zu%SZGqrWbp?apTE+HdSlOQD`sAa4+~Xw|3=q
zj8f{VUlW@87x(o?|D?g?pWJW#2X?ugDFmkYzRUV8-<iQ#Url>TusHi(sWjO-ZsEMK
zvZF_ElAzu?xM5_rH)A;u`iHu!gXcc&!bvn^L3lyhj&mu2y#R6D>CE-yf~+2i4X@FY
zWw4<gvN8;VD|09Yy6)q0JcVzx%O<`wvpBHdVotqjh46X<1l{a&>r)cM%Hvp0nJxkY
z2=fBDd$jh*Vp=v;Hjs%>5YdyUe~=2BqXN;86(rOE#V`n*jk}h!Dk66Q_5?>Vv)ZC}
z<vPe^N}r}~^AZsG&WMY2&$}{@;C-Neu>m<@E3dzulu(iA=By#)k1}%%kX-Ss1O3Y8
z+bN<H_s~wKkecq?#dkcxWg5JII#e7s<wmoE1{qManw!n=ZoXrh0w>7io#6#AnmnY%
z6kNXHP^30EzBgqQ^fgv1vpu%jA3fiF_6jhlPe?lXwzi^<`8mC#lV2~^BsF%0XC+4Z
zfMr*wV8jk0UA<H&(uqwb0V1viRPtflthmiV=X99*Zm=j@ui)agnw<{VncKX4spXrs
z>%YD2XEIQmO~ly1hsaXN>*7RRl*-jyn%GbkK=Wr{u1L)^+ud)y#OIsazHO3mWWW7%
z5+xmtzk$(CAcnY?Dx|G^-&A?zHa+U0x9p*!%eaoGpm-e=yt<AfCYTnQc_TYHg-Wn&
zG`#e?iY)jeqxhY^%bsNBrv#?psB&C5!72_URxtsPsp<9hV4Ap+IlI%nz+M!A@bN%V
zccw6>VQ|jG5p%(=fH=JW6h72;Jc{opi0^?I6!S5`OD(+dOU!g7)GId{0qV!=#Pm%(
zO;-dQSD;n7q=KItYIdricG#2+(!e1AKjqX%#HSxY8`$4YB0e@`h9`|4mXIxn4e*Hl
zgZARVk-*CMO$8@NiGh?K$)lTzl%GIPI`L$5c3Ikyl0N>LEt2vNE<aM9%(;9#OBX^S
zrK#I5Rf-iT3AASCTgvZ=n)Sce!r64uv!AYI_1#`?27>3`!frgO?`|neHmyjp`eU<@
zRuz8*HC)#d)Cp=M6~+V1w>%~K#JJfKEgh^BN@DdC<l38EvrXWz+a)&FmzMW1i7PKq
zr5fy98=JHQ@*JwP1eRN0_}2-BEji`(p-GWQofbKTSwgk)m7vhKl42}2J87-NQ2L0r
z5<9_N@I4k>ueeL_emY(a&p}4|k))gu)s36-se7bzPWTw=1;U`YNRUp**l1rI174qQ
zcwL2%z^&Xpk>M{%(q+eFS9j`yl%oQIROd%dgm~w=<zsoJNsDb4jMp+rq}rRCV<P81
z7wVBh8Nc0gRtuuQ5VZ-Dz`88akc2acHfToA5zY{vSQ7R`=5`A5*|&RuC-iU!X-oBn
zU^ldmP8l&@Mrpz7wu!`7ii2MR*YAr#!nj|*A;*Hxf}b4`iV+$z$+{Bn9^xP@fAO&d
zL&7!^>nnt*h+-MNlM&}pk=TbpwL4+0Be3`$SwfiogL77oI)V>%r99}D0~)S6fh+MW
zW!17w1612jsFgf|y%B-}YJW*QG=3`7dHxi&{=)8G5n3cFx@d(I1vq-Sc^|oR@!l%O
z*UfQ*D*g!Hun45UACgPvzhu{V5_cE|g`?bbiqD&8_yeG1YBzgfOt5)AIJC4vEg?n<
zmRqR>X3R-`mFi`e3A9!UV!q{#0Q4;hq&(b^VrITrL>vUx1jF1dA|;@Q2M#MI5Dc+P
zO0uDaxwONhGDNzgUo^C#r$DW-CC6v5(`KSc(DQ2G;r;v<k%+jM$yU6htmtht{BqI%
zvjieu2GaQn25X;SWrF*~4IE-Q84+|$t#u#^00BkzPsjvo(qe;imq)}V=Eh|egSP&*
zY?#`$H~fE(p?0F89UPe@-zyLEkhGEqWL5(vc9XtvcXd$INT0N{{0fJKnA$D9#11u(
zVx-mt!8ySygHrBTWQFesa)SjBD>cb|-hcmx^Z3t!{Bj{z!5T>OBUo%1XX#Km-A{tf
z1E(I~#G7=F_ium|7xsvp=9HLp@aAt6n8GYKGf@L6LdSHd=gU<uNy`&?x~vMxhdy$&
zJW0q@(y^l7<SJ^LyyeFBjQ6Gzbum-fjS=feja)`sTq)!NCV}OKhd%7y$g@!)P-CcJ
z;IB2shltt#h6uVJ%qiv?(pi_a?-w`{Rz-grdsfuf?|eTU4(%;?9E&t*2<9<|#ApTs
zIFi&PT2KQcd7tACMDjMJ%(LHLVG0B!tzI#x2r7@~ye#PfHKN26kt`KW>RlPE6T*#U
z5>NhkA^r?9WCsh%sFE$-_>&2SO1ovklL*2HbMPorp($)T9;@f{{w;z0icHiKDq7Z9
zG1`GKLkQkFU3ruhu)1n6wni+HKk$9V<rZ2zME#&BG|v=*1X9%Rg~I=gIP2Y$bxmV}
zS&-V#vxkXXz8B#`p9iG1!sqbVh>z$aMe&G0H*|_2FR|Hq!J|jpWE&~n9Iw84LL`tH
zxDsU${t5;3TnE_2H)9w(C6ItHIYmc_cM`?1tZSjgjzpFdIVZP3lfn=LlFNi{rs}>W
zH2aDPaYKU&{Vm(3n(=jD)N{TFv=lJJv#<@dq(JHXFAl!sgwsGOz^)>A0?JH+^<3bM
z-Q6cUujwc39BmX<HF#BYkWv8Qa4BaMyS|iJ21z_6P^gilRm38jkoz=wKbu(Z5|R+Q
za1)I+pF-?cr*LTwzG&`npt`O5O7Uz&IkxMC*lY@EM6{#{_64Dy886~PgKCKjzDYqN
zxk&Cc1{P8^d5fy8-Tk@^=ntVg+q<MJ+~)@@6?HyIP96>jSV+X6hKdR|u9i-ypO*`l
zt%JTKY)spWN2{IQ{lyNQP(pv#yLDT{0Daa^*GIn6iOKR}AEh}yy647DN*eFXVxGoc
zNLCA&dp`6r;;LE~mnIrNet~oGeiL_%8?<22_+?V#skQ=kZsUByc3aaQ7hq!l#-X}4
zHv^rr-rOtc-$B&m_nBQy;y2Q%Ab=1?=#?g2cVEesm;ZZ=-o0T$nQIGHAUrOB%g>W-
z;d~8aq$7EOo%`tVGq@Lu&~$Fv_ufd0-@8ORmI5uBq4s3<0ued7nkvf`QSN=#Gd?GK
zazo!h8{+fts;Bv<g3Mm6pUk(DW^4LMe7v|cC}W&_xfpWt$m|rUJ#Do4SyuWqAf9;R
z#Ul*WuUfaYXPF|Jn{RvdEY$9#e@MQO|6<t8nCjR5+QX6KT(wx+TLu&zn2r!JgD7-;
z#>KBU8%+HDyzYJ5dAXYo3_CkZGi#tQ+3p+?ot?>#Un`U}Yz)_T&c+c-uF?g#VqnCp
zt6`^YM>AvUgjB4uZDX!RXl`DD%)at+u%RJ7uTsSSOn@2R_QYHAd&DU+$(5E@<oeL-
zbcT9Au8TH0`e7rlRlqje;9X#6W%J^!?@xuF!oBlbld2D8y2u0mtPYYC1~{a}Yu--9
z8dBpk&+><{xyWE^v(G+)$ltbwyv%~)++u2JFnagGU>lO^@1_0;pFRG$dvEA<FOeS-
z1=>?+p+g&n7di$20#9~33oKXghWeh616HB!Sa_w;9OGbz)j>m9apkf9iTN0dOV~sn
z;jMw4i_T`l|0<IC<>z|7q!D0lu`hM{1Eb6PqT6vnzB_;fiU2fM;DMXo`waneBJ1Uu
ztwp8=t%>0;0P<1@#vjJqC_p7Rmv-cI9_mQ&mP+ffyP5x@$RPIkV_*E&S}lQ!W6$)(
zCX|NXJ)nHOWq!)^L2i5xFpwT6fKbU$dA*tx*H`DhrLx8tP)K=4vFLu;2Daq)3PWB@
zF6uVD1%II~B%<;`spkW8@IcgKNdxWqutrBrsFOzg9(8y$_ceDKHlfbznIPAtYrOj<
z@(j~a?W{N!muugx{C(hIArZ`9HvcU3+00j)d%m_^cUSL=nSBz}?6g|!zAfwDoVQat
zhse=iRH2^YPFN~90@SngnHd9ohZ$rmO{V_z23s_O^DV$r&giqQ%JiYQ{R%}&BVz%G
zfs??MZ-RXzOrr-rfR5jiW(myu`#kRbX>gqVz{j`-ai)c#fkFvsh!aE1zroDJJ=+am
zt!86sxY{nvi-*8O7qc~}1E*TW#P%MuV!m8pyVle~!WZ)f-mG*IPd-y90!C`cVy`*K
z$heS7{yyqsiY=UPjGE%Ryrck=uG(I5Yj0ar6)jjFxo^ld81-85>%1O}`4>k-0a6kQ
zh~)c^eFM(ZPmOFm6e*+B`25)Z(&l+kNk#_;Cd|+@=IhvIcw9gmG$aq&W;-z2<;$%L
zop8cX@%Ru6GV01)p*TIAOr1Q~=Fs;u$q>njmUIXdx~(^&itHzv14Bd6$R;)8+E5le
zgWAjVGdHBA%gnBiFwczFxvw?Lr1V*om%f&R+DP;OXk(%tNtutupbH3+fbD=$B;w^e
zaE}{(_j}P=-=tCH0Z<1jD0H)8^>pq3JX}JXH<E3}<^qQ@f~8#<4lAD3#?7~D2?z}!
zB~1ujyaZGt0)GZT{%jc27b>eKY+@%<FEh4FY<wySfkaiyZHxM@Q91F>kL}#2_7~1}
zllS@6;4|RLqHD~tFit2??=+fnw>#ID*5~g%8a$`vCzyN|E!$bz{tCHV;Hc0vA6}Q|
zuE7u6J{*hwGetr3a>9m5AlmInVVqG*DAVUK`a^H0d;R-d^Y(x`WLAsw_u$n?I)qQ4
zZ)Vp^)D6;#yT8`M?3*n|-tUIw-mSlr)mok(K`$kO>XfDKOpqmu$v;ad@gfaAEcfy-
zP+!$`G_?^8-Vbq}hg&UJ|7zJKqztpwoVay^k~Z=|AP@=MgZwE(pCEL*aN)j-6w1^w
zCfe{v>WD1&`ptg4glD)kIiFwh1FEe3Cg=5XF%|4VFNGfmQ?Y&gJ9X|z88J%TKCkU*
zMTaKNu%Rn(cMuubo@iYl{QyRd61INRtTmftJNpmg+Hko6bVp0wBDBQB6>yA_KOXt*
z-L-u@FE50td!DI=#(fjPJNM4STt_3{6*CXD8U6%owTVKAS+_c&Fyv#*#_#hle3u<f
z>2{qZ3Eey_prL8+;4cZ?)n^hM37#g2^(^AI1mv>XSSGT0PFYzKH1g6NRW!hPMJWi(
zVRV18t*Z!h%<Z>EU#R^&gA|t&6$QVC!o2<VWqtF5eMKR-DbL3%$32Iugw=J1>UDv%
zKUU)x)uoDHyjrrp@j+V&l7s{io<isIqDVYHvP(TLUdvZ~(Tc7hQ3+9%XL@NgTs`0@
zIlo0N))4!g;J5q#G7Seu*)M=0CMB0=Tr>hjU2Op9qMNI)scDFu9idu7k)Qtn_l$k?
ze(JM>lWAYB4z}jc1X>;cPN~_s@;CE*wXUe-xLXzQuJhT=BRT)p<<uEzV`XdV>7{0G
zu_*Jiv=T-psLOJNS)+=>ugv#tuG?s#cDOfZUcu<v?5bn5%FjT(*vI&(J_*6lPXzfG
z9=2m-RO4G@{zZ&YI1wV<mVX?B>M=T&Xwj?h-}|KNO}b~<`{y#|-HLjno~}3HTo&)1
z$6{IAv!FFnw!t=w-|L%%@MD50cP=35O;46@K{->SOsCURP4@(Rh(C8$NxIqhevQ^l
zw_<?^;5?jhXzmE8^^XMK>j|}nL^p1#f45?-LE?c{0#)D8XKn}a9*w5L=5Of#*}K4U
z9PfX=4-*WYl2?+Ht$=td#kz{mugj1cIT*euYOJ+0VCA-yK#y2I9ex-XGOEl&jB7UM
z7KNNr11#9iG1=`)y#Zn~wyVD0=K2p`gzEY%T<E?pa^O#6;KQZpH23s;JPs3^2+*gq
zWzNn5hS&(bVWHH!ylVY=K_N@4$Lw@S;J{*N-2Wmj`QPy5z&yii_}-G7`|pa|f@a@l
zwj1?qy)k=b{Gds()0%#!e$KlmAe4ws*6_bgD9z5@?VXW|{Q2PghS^`+ybaLl(usf)
z*bccE|M^<S;QeHW&2}ipeRi~NcvU|Q;pN}+#AXn9=<(QF?RWfs$fFhMTDj7O<Dae}
zf+z?xv(`6l8Q-U6d&9vFs?zLz?RM3Eoa1;9)7>Lj7Xg9RAIF{O={~CCe7zwHBiG|z
zT4Z6yhP}zx@Stp<9jSx;PRv5`%OFPJP)(x#Xg|)0Z@T?T#o(No=5lo#l^C)fQMDNx
z9>t^{LrJM}z?Amb1cfm&DpBuQLkpF{JDd#b;nXo~&{!!V<pzU-#7ZalZ`KFNePxWs
z4%A@c{QR}18(Q*yAd8nvjGyZ))4Qjl03e{d&vK@y62WU*Wbi1a1n(4Ox}f*@gj^xQ
z)y%Ag<0dfj4LtYPO05gcdO=>Wl_;VhI4!4Lkf);HR8B0mOAk45XSv{efIu+`c52rP
z<oM;cddOzZg)7%QgRs3J1mn{9$~M27WubaWbvQ^wQ>c>@Ec2rK)%`eQ$AM`TbVQuK
zDZz!5RLKehOu~hYr=Z*&G}>m?Zrk@W*_GOjwYJDXOd}iix3IQNK*59S%hBXah>pz%
zm7HO@`N0!M?v&Y;ZaxF-*?xZ<e-sB4#EKeWoFZhTGfPMw*l0tgcy8d^710Ty38-&Z
zft5QE3*{KkiI_whx*(2?%U$wS|3#>E5*w=i7>WWQRGn>1n}Vom<QIr>$!o_bCy2Kx
z9;j-=<ewTd=f2Cky7Pg<^(J)>fe?i^y=B2q8?dXN?|u~LD8pk6I(e;SC?^bI^Oyd}
zZWUUH)r#GiL;!}cTX~HDlrol+nD`e8u+=j#gelVE5{tYIp}Jw&Q$xH9X($C)KCrtX
zDJdxGFY|<1Z|Ij*S1=cQEXG0CUDKpZyo>1iYDb52R4zg%@eEBQO$$Qj|Bb^46>@FA
zdzAf?fT8Xmw^9UaAbG$7E#lxVT7?~y?DkBWf)Cx0R@0VWH2nDv^4B2{Pb2{&71=85
zXC3vNew1{0cm&n8U-w=C4vM%}jpPBGLVOyquR8kcFj$m(Ngm1GSTaw|#jBe)gOV-+
zomgV(@A43ZMy`~MjFCHm4asSMN?#MFT%kG+d!FvMP{%|iLlk*r;dl1Hx%$WNxXyjj
zj?b<g&NG2Szk;Aq(R&rNHMKl>fzomJJW0R(g2E7eqC|5+F^4$refy#Ro>yH=tt)h@
zU^??jTsP)!%&c!JNub3q2MiubDi)<S8q4$-YfR7%sWV9^dSvD%T-S*`2c3no7nDpT
zVzo2rCNj*=;zSZluaFIJd(!J<rx71Mw{)_5tkRyKEgpxyBRZ>divUzI#<@6>sV#GX
zB1W=@kCo>ae(R}Bs)i<DDSKy-oeJ&W|7d9OTWHvdw6SRFZ0NRa^65j#nzqlg@A5dl
zkdnR8{4gXv$5Ih*;su4^f%_o!87kHGrU?RfXb_cSzhKl-?}Hh>P%|Ry-`kC$*OQ;c
z(3d(~rab#53F9h$rXd^ZCqXJRFZZ2SRM_Du`pI854U|PR&eQLG80vZxb$Y!C#uPXE
z=@Ep%iHi5sO|c=oFg5qYtvM|B#7@;&3bnW*V~I#c2akYp7T#zA6(*e?{-vQ2MFW+R
zYG8{x2HqIV&d%jGdXdVFhSVGhqPAD$Idfo0Y9Maazw_r9eqbO_t{23@c$?+M9h3+U
ztevAvb&A$C2v>}`wwzNp#CkZyzS>Rm&jqs%9?Odgo7I106u3|!VefOd?{tip>a(<j
zGoyr)(`v{XAO2C$1FCDz+R|phs3Ow<vvfsftigo>$N>biUHS>kofT~V9Cf=xKnAl9
z6@o!gY6@yn@<YMpy(3FkCPo637aFz>C8DyhuHxPx6(?A*)1Y#UA#58A1{~$DDw*)8
z&yNlHto-t_f4V#I=iw*qaVmPbFpvDeY!++}XiCGsz<r4mA5SIuhFnP9OIgL}oeiRa
z*j+2-pDJgk&mt6xU)s#sW~w-!@^$LnLU@h$v#&NI2xgxPeNr(}b3|RrOKXXRi#KXl
zO<hVjv?wV@cQ-OcjHJsZs~}>NF8zo!Fzcyc`5Idw&k`IW0?wUO3#U8F5ddu2T8pUF
zW6%7TcM>Fkd^}-Xmzh4WGM*FVj8OM0+Hg)%9JNXOk?KC=7P%pWddyD#8DRml%Wb)^
zlK63LRd#p1XIkocT%Kl(sjEL1JV2j_)<42;h(VL3>2O?wC5t)^mrZ1UhAn%MX(6_t
zvMf+Mrz%;D&wc6j^lw?0!+P7M<UThG!5c0@PytgUYh%I)lR?z}c-e6OeP#k?B+k@G
zrjN{q%z3+N{FO}BM3UixWwIyQk@7w)etk*K57rn~y)ro>8Pe%-Y0B&*#SuA?7f|<)
z7|jCSD#ZhN{4*o&itPu&Cg^lpKCu0tcP!~=jQ5f6w`K=e<GBZ#PI0Q6UkV*K?7F8`
zkLC)mO{WooS615DIZL7{<+cQl%Jm7>qLvuFMSgGK7F00e%acnucFi^Z>6x3`_X<<Z
zH?7)D^67o^GAhSy&vUiRR<n6>Wb_KUiL^qcm3#bze<kZfkNn~MD&HZe>4X$-u$A_}
zI4|x=hto^6*^{<*jIpZQ{P%K)P->w(k<X*Cz0=cf@p1?oePUY~1uh{g(iiF=?h#{^
zeRU|QqB6px$m3c@=)Sl@_&kjN2FpkMad7ERyg<=fuRV*KPY9}oJKR@b9{PJ;q214c
zZc;q|WvW?75c~GV+fT_uW*#l&*>ticb>Tb^?N@nIRQ|scV2%&PT<c&k4Y^;~+VI~x
z8;x2OkN;(7v?W6oS<!B#(+K<J0|#DU<S`I#hk#6G2se<V`er1NP8le1D;^%%ZXxO=
zDJ0f#r__#G1^p>xJkt{yI8|dEDda7P<b8IK4D$c-R75?2u#_TAvbd6>DYg?lyQ9hQ
zDRtDjGHz0GGW)1T3bKrgB-+P`>rEgP5LIF|i_pJ+ySsvAn7KD~qRWXH5}ri>k`T#3
zd1aFRt>S?z01JDhjbWq{QV(}nIB~zZ!$L}p(;JqO+b;mbs`Uz;*@s;Oq|Hcd7=@*?
zn27_txtPg!xrR|&*<gCOZzf0_%5vu=A(r@ic^umWMzD8NC&0dSF5JSe#TgHR#648L
zgKJC}&M-6+9J#YJED<>sW%l=4O=5~mkkkg0KOK~mJ`jLYKt^_xO}DF-^+T232FQyi
z{4sMDP0-57A8~!#(vJ8QCLF0OvzsS8F(!0G5?0n=HV0%SAjGhYN6alDj}D%NEYA=o
z(TZa0(YI<aQl<}>Vqw>(O-)LL(^>HzsoF~N;O(xqae`wO{LudjX198mH|cxl&3ghl
z;>rypf2EZTPYhHQPik`gfLUu9uy2{L$^?o5Q4%4;ZM7MuCAXpbSW_%9CMxS=h|$Gn
zeugpsp5%jDQay>S8ygtXATQWij`No|HI@JOHI3&+0w-(-MdP(Q{6X2C?lcEMC;8IP
zkTyfCHiu7d7VPLX&kcT40CqBY5$6;EBilsJIaPAsEJRDM&_7CJD;`vvpTNK%pO#V?
zBSTE(=F$}LppHxp46_|4ge6T(RM8^7JyCt?T}<8G&sDLuv->H-U#>~6%Qy?N3-F?e
zQP`XY(`(-(2yQK;)|bI(StNK5d|8<m$6d<K4L}9YBqt#*rCL>M+ZM3ERctbZF4eW*
zNkhj<Ie^4s#0Bw(QD?{3Z(xVnSH<O&9NLhkr-&u)6A8&QaZ9SAUZ*k&6mwJHM90Js
z(;I((=chi?J{esu*F+(wYPZ2D@6vkVM>rRWXv$IgwYhq?r2NYKm5g>zb6I?jr5rVP
za1toi+>ZUOzTAU=e7tf#DEM%&51MI+>IK6FlZEs2Y^KcJX>63tBOEIwR3@VjHB-?}
z5)q9FJFwV`E<YPD8%8->eTOUt`ykRlE$NL=I;}cL9dC$nKxxRa?*&kAz_`hOx=#Qz
zLJG<PUCb7^_g_oNOa*g)f5gm#$xspZq<DWS)@JtKO0Ce{Xy(fDoT6cN+rZZ9b|c%k
zTNh&G_7!-&_l?gOlmA`yJ4{nQ2Q1g`ou{A3>7K;#)`|+~=7!0L*4Weid1LT=Q0Tc+
z>af?fzgt(%X!?G;O!t`%aVMy^V^b<ueb>vsv)ts@5{x7OGWB{>Hd81`$<D#iyAdZC
zj+NsdO7k&~_5_rWXtU~Rs$Adwv~Lejp*iU|ZL-PJyvnK2)zbsx(sgc^E@!*g2Mo6)
zbCX%hMN4Z>{HSURp&F%F0~x_kL)!Z>LtH3Jy?!IY@H@GVI@^lbHhPydWVFI5Dp|bI
zJxAcoN=E=$(War<Z1%*RE71TAh4CI3g#Xh2G`>^Gb0y-cj-czcsJOe4n*{@R<R1zE
z(rrBc!2yE#+1U{k73~TBNY?lHtFHAt`Gj5G)Tik8NcKGIS-KnY3DH2htu4e0(e=8g
z<8fn9-RCJJ0O#k^i&L``?a-sRjkL`W$mi!-U1qfXLDkcsTAIi3*T=L}0pu&kh#&>;
zeQgO&a`tWYI0v>|qau`w=z|X5cf!bVO`EEh&%qa@-R;u+b^C35_<A(_POGb{Ypdb(
z>@?LdJ^|4E(fwvL{HTK6IV^=%%2w-5EY;o~p0V;UIEZsACwTneZp=ny%C{gfqW?r#
zIKYo-2h6W%XAhRrW}ntqS^tBC(P+dGX^_=j2fae<yJY}gDK@h!qfAHD=<dx!qh}T>
z$HZV>?}5r)w0=?pY_nw+Rs>%0hIBP5>+1ui1wRy5I;`lF{#LGD)fyy&K_M7o3OHVw
zIIhdP_r}^4_lexe(7|J1q$p`CLm2qCBG1ju<<-=HJZ{*q>y)KEtm!DJs=`%wu;ZoH
zCK(awI$h5%&&)vUG~2QX?LQI1>C|+1Yo;^hS}Ac&i+MZ0G*)6U3J4&uvauPRCSuI2
ztU$wce*}7V8hjehza5$#(ktaP6*UzmXJ&$dL8bIK`}+bo9kyT}9uR6qb~tccDJhXA
zdO;Gy5V{rRg3tyJ1iD@<lL<$Xo{u{S^{(Y$BlJ*r3)$q7EeRabqh5wHu~~9lQ`MB0
zGORoz1NWX;i>18wkg?GIoTobs4h*NyIJ$7ck(<)2(5&5WqL>Er!d?fA4Mn|e+9L3w
z%F_M_2ql!_ZoKNe;%>sIb?P?{`_^q=m^7dvcyJB2TOd1aQI2h+Ssk8T+^%IPET-L3
zDNMr`ZlG>Kll6)X<~KXQ<}m_%zTQ*>A8~uwt4DFI7ioA4^RxRCS_l#lG*m`KG~UEz
znUZho&O<+>&XAxWWP{89I6<@%DCsxeGyuJ|49y<PeTMu#%=*;ti?j)o6vro0b7GTB
zhztf=E53fI{QFGlz#PQTv_Q~y^|CSlXOhmeef%+!93Kvyctv}@gyn&_!zL_74)NC?
zW_pt-)WkZ%8SLV`GJY!8SU)nOolPl)W)lU=pdiq0_JiV33{_5H6(r^dt%j1b$LIMw
zd5st)?Hpp6i#XT6C7`s^bTnY)WTyqtK{epsU??yrTcZB1E)R$Eb3;7uoaS!1K0apk
zh;>2?#<(6=+-4aj8U@XmK4L^ZI9iOGCO->HZ^}^W`grA&QdA5li{-^WVZM0xG)Uj_
zbAJ2`&|u5?eDnWuD{&Y*(wcpRg$WDu)gvVdy)r5#W*)I1e(;Jvf*>H=hI5OhXK%&P
z7nmr6<5cTm@}<>S5^}rDhQT<VAc!|u3WPF?MFs@@>QKpR<6Cg_M9fPC1z5;ssRo=_
zCmGX?s6~zr3ogydggnUr&!IGC08zw!<&PVn{iQ>L(MutGr(#qrIzeb!rW&!PBgG*Q
zsJ?F){SRFFvE7_ly>Eo&Am*V(6RL3^2vzO3SmyypI2K>=wj#+>>5zGnaoOs3nuW#1
z+TwFo-CInW#4gb|Ze+h_dm0@<EPj`m0jl{kpJ&360kEG9pbt}-SM~myZ!^Ae{WnyE
z2;MQ<!8G1BQ{FYktF&%4k3{~y2?SLH>>eO$>KbhCc-WRo?SKE|GS&Zen#q3)cQB<&
zmf~vNE=ALzsT*aPobL5wlh9BYUlIPbmN10<BHkS_jw*^dT5})`MA|*t7)hg7NZ+6w
z)QB(RRnYIm6<*g9<`r|nP*bi4hD})*!j{Zm@O4p$%&FsU+$%_lfJO%O`8*F+SA}zw
zFZZ%3zHgSXDSe#*J&*P3??0K|%lc_Sc7INaIv!3th^0^0I%8#W+8eb<y;=?i<~({l
zT_D-Dk=?9Dv>TDEv7y$sST3CG{)j>BQTf*7LIDRobjcBxa>&F>BpMksuCj4kpr$#F
zWH1+~E7MRntC!evp}y?l1GFILwS#4Kqobu-NrpnixW5Sw8G5EzrHI%v49}o|k=N!C
z*K-dC(N9Jn=_~GtiNV<5XT-$=qMDm;vdXCi$W@qRKXkL>%lz`xMx*+jjo_<g=fv4B
zt17mfUJ#_*_KTSpULZa%*txsyPQtRU5`Jxt8fS$Fa_81r!W@z<^=A$gF@2#VB;u<T
zy<(i>T(#Vq-^loQ=$5ZntsT6vR<pUlexboHG09`ns&qe^^|NQcSyVTrX+<Iy#a@G!
z`($W&6;km!)tOTpM<kC%2I=cQ2EC3f2t+CcK1@s3Ai}%i;D$S)&!|ewSvM$%K$ou2
zoWJ?%Wrwnwwf(6s)b3*og@J@%#djzJPpcbDL3kT5)Tbp6uP&f>>%(HzD2wyBQ-*cv
zIEs*pVm0b8vjsWEBEXg~?{+ybf@TVl0MQ(fahb_QXmH#Ed^^ku_~3TamDxl~9Fk*-
zL@`r6rkuo-nKd9jfi&h}l7&Ma`j(nYSI<^F-tbK6(V^@2JrV!+dQ+g#9RX_dhF|At
zP&fYr(&NfunMD?~OP)&6I?GAk6C{1wCr4In+()+O)F`}oT*Mq%5uIj*(IJ`wFJxF8
z_SkJh;|(!m;C$qY)GM_XPW>_U^Yuro2t~WZ*C)|^9`piF0<Fxu@j~eHFY5EIzW;+f
zJTzrL5m9?41grtWGv-poHz+cv#=T*ztWm)QaC9;L&yDf(NIY7hm~y@4O-G!Kw;6)-
z4>Y1Ku4Nz7<m+r29tXKLz3iH%-$>aB5ha`JV^srZyM(3Aptj<aLy(4cm<e2@!cyuO
z0ulE#i6JHQ<=*g$m1&965oJ+uSj3N@v`O(6+@Zb3nBd{!wgu3pbXx3>Svp|^SBy8c
zj2Tp1*P1QU`#JOxN^<A+leMB77Ho3IZ25iaG6;y|>ud2rFi_uUL_k(we(Zt`uQtL}
zxcJ_#Lhas0n@hzHn4ZR@2zWo3qCpB&?#kUi_8paAuC&g_IM1DZe<!pocf<NQC!=;6
zn>|FPiZ2sx@4W|*TMO9g@`ZXtaCa}RMD&Uafu%BaU$9~4vejAKh3VL?whVp~*nNmx
zYn8qpFdz(|W9;h9s;-c8w2^N#ml*sLt;P}p?Yu2Y{$6WA7*Ou#7hEPOZ&pBNVG59z
z2>i{^k3hqS4AzoItC4K@JSShJVSbX#q$v1?JmoZR7OzP7F#Emh=95}2r1H5iyn9x~
zD!F%W9txcrFXFTm0iq6qiCZvH&=X@oT9KW86?q`mzk(4{<bcrgOuyx*PKTSQ4B%ra
zGQyHKfcF{|QpOSnFAvU6;!%7N<*w*4YwhvX>pup?zne<kWxsO4-shSs`QB#;K&k8}
z5RK%($#@@dU|Q|j?IjMMHLl!gM!p9h`98dn23toY#AX@G(I$p)neUFbkS8an{3;mX
z1)o9EFG<-+CP%|B3L{|rwVH)ljvRKoai9;JvzMKXb@k!sqwJ$)-ai?yn-d93GNFT3
zGcv&l1cl~_sIf814`SL<AQF$f-!Bz~KvhnwmR|1xo88j=e*g_Z^1f|gQioR|4Qn0V
zRxbm)RJ+qy9z~;AbvKxz<R_oTz~a>u34{x$Sd*RkLMjPGS&JeDbA&8|)h18i3<Zv&
z(QXK3c)JyxmVetYE+M2?3A9xv_zS7%*E`BHCUBb&v*0(W3nF2YC<niqPidGopa-0*
z1g1E{UQu?bHR>Y4rL5qJcn$rqWkijdpwoDOwl;K9dw^~>)kjU;xuCSQ(OuIMf8lkv
zO-{B#n4U?P;3$l=rVZNKuq6W}`ne4kWx<^Dkk2L0GJ#1|;~hk1aA1WAHj|v>reqtH
zS)i?rph-L>;YH6{HDOJQ6?2}=@YBVdsdNT2pP}6?;#D;}92=GXDCt1L?iyXv9<X_U
z-)Pq0C(1S=UFg^z@Ed47Eq5#w$0P%VN92o0;Avra2%lcf=Lx1t%EqSJA;4C&6}WgC
zh!yBdeC#GDp^V2)=Mi=|i9E_dRwIxV&nm>6lohe8b|0`5n$-P>PxMMh2u4ddLVPKe
zNDkD2gyl}1(;i?Rpj$(Hv`e~(2h`(igv!Ol#AL?K8NsCXKuZ&dlnrbNTa6Hm;%abH
z(FEBFoWKSW1(U&Tf(s>hY@|w{jl!!CX*GiQcnF$+9zZJq?8Q^gTH1A4Sj@3URE^qL
z2nJw5hSWF?w80eN!uS*L-#;U$)oAU34(WlIZlVrZ6Kzzu9-u)ww%%cKni((4A`*Bp
zCIBw#N;XMJ0!vwmAd0L)0D(-6wgQ*y0x4t&3zR6A0HRg`g&4=xn#B39d<PnfEP$Z1
z3T8#zG#nx<^upWWg4zsX1i&EUCo<eh`RWBHa;&eJ3cTuK5{QgLrvQtqUXc)<(ARF^
z0lFVlpKeikUCH=7;2x_Z$}?HajEW_~D6L{iI859n4n-1J$~uVLMVhc&la`~}wxX@T
z<tg<k=!A9`%2R-gQi!l!`5{XiNKx=@Xa&6l@-u^0BWUC@RsbX}3|v$?iI%2!KcOTg
z65giCDv)@IR|gW7Yjmy)d4O&Y)u#(pQCB5e52(i52r^n(FOnFgYy?&}+LPB4;g-?n
z5OEhd6iZ+!>mV}jK_W1cF&&Dcb(5NS4q`<Q!7i{1U>9$dBqc5&0VG2mcpgN!tanh+
zoF1tyy>+;RNfz1OU}+=t(5DJGY<xz+p!2oLiDYH^;t2ZIfrQGr8rEq%AiA^j+G#4F
z4Q*Qwc#ON=Mkp4Aqm*GIw-scqo(P#JV%~WlP&u3=Bs-)@3Z$$>B!J?|F!FC%gVcr>
zQ<Q{r;0fabxd5D>z%G;$sFcdMX<NZ1gNwI)D|(9!A4`GjM(rvC9Nk8cm^>Z|SqlUW
zHauj=t0O5z`Nem5(Fr)cK2-h?e8w$TG4yi$&y0i<W%>tMBCm0s&o9(=qOGZcMV_vd
z+Out^8U2iImeEE(qrB*6)6sS+Qy&z0jXU1-g`Z!@U!twig=U^$<kK$YPyAmkC!LCZ
zxf%NlR*tTobvN+j1o|(u^!o7WH(!Y!NrF+Mv7g<<^9*+~;*7EicRk{00H=1i{zlBB
za>2*T*mv=@@YmmX1+$Cejx)<aaKg?L@m1f~p&Tmv@sTciHMaN{;v!F1@{QXTZa3A>
ztiy8d7qfnZqq?Gim54hL{c_z6=qD_XL>$YbVT7AH?Rb=9+_y|7ZxgEfNytYyUI+3u
z&kLVX8BH|Wf#;W_OlnKfwye(^?M!@Z48bxn&hTvaDXe|@Sch%2d^PJY^xv$hPTZfD
zvHXf<tI>DIqMer^5BIg;TfS^1+A_r$GkLrFj-Q5IV$34@NFR-LB%k^Y*)kRXFOevZ
z8a)hsjr|36Gd|V_xi9En3|wc}MYc>Ooa9exTWXV)D3kuz(Y5&R21p-WsZ1YAZ_a*~
zUHKP}T-d+qLR!*GDXAm9BAc6}zdMQt+WHmQk?JivZ6rF4kIw^L<`vnI+@R=C^d5;T
zE>{0L0BhKk1S@1nSX<UcYAeWOo(P%9m5-Lo@k5r$d+eF};i^k+bjkJxD5MAw8pM7T
z<EyciztROA6Rx1J;kgAikgcG=6G%bBDcz_ivE9A?4McKs3Y&11?QaNVHNb6+mKJ=4
zw5MX9R#Kn{#C=Hmh2{2ZYil!Zr&y1ha-I~%XHlYENGIDxbxFc{`PGSZKJp~KBKvab
z71>M|ZTR5|4F(dzFuk>5d0Xc?fCog^R9!oOdD?_->;aD{F|bE`<~2!1Fe-^5rmTE_
z#Uy|+krYQV1k)r#|2v5$BLie7v;p~aMj$iU@EjThABjfDSBO^|$_UxCD_A|R{^uiX
zmU+ssBTz3LnDk?n&SY>hgU2oiOOAde1pzKnAAo5J%a|p7M#9Hu8r23Kpspx?+CZgN
zp*_Go;22xm!Y!ssGo#Y#i&Qb#Ve$<XDUY0j#4aRgiMX8!C$nUl0PQ$?$>1@8l%WaR
zkvP}{I*QzQ6U#G784emzbkPz*0Pz~>tbvfjuhed;wi5#F)MiP6CJ+lEOk+%HTgJJT
z!+C5Zt^)V6La9vYLR$b8zh04$ou~5&^#Hp$P=kC;s6s7VdmxerRO7xck7KfknqLwg
z53eM~8sZUXD@a6MS#dKO_-NTVn=FK{MDS&Aw@{hVG|2{31QSH)FwDW?k5}-Uy4|8V
z3KcLN>=8<t+9Qu`sa}zA81BLD2BRM+5c6YKtVTG4H@934VRiFDy5LSDoMrvghRbCd
z5RL~#N0qPPNY+xc2SWBhloL89mzbn%c$Nhh8l2L{I%#f@?^%)e;gnED5J9UEwuDk7
z`Gj&5IkgF-V1fq};+qi=-lTD`P|<;NffW2)3jcPq3oB$Que_=i+!DRGWjHf4z&jwE
zs}U4LaDU0t>}w?4BK&r&7TGu$j#*&?n+{g!akjXFQ5Urbf_p%8J>FS^^Jz-$fp+(R
zY943{qr%o3wmicJ;@<Xi3H^d*A0*;qfNTsx96}sLF4_j9f{-O4IGEELcoQU%2?7_$
z1rU@%mtktq)d<|quqJgOoUQ?qgNzrsA60>oO`^0SK^A*&Ysl?@5||Q)VpFge+#v7>
zKy)BsI#6e#^#FA_`4cU_rq>?mP#$oMw^7*^1+R<L1rVA&5rRN{jggHBi!_g@HL@SL
zbhy&CrGd0|amHw22RdjB1qP{5XR#PL3m{1Baw6f0OF?6TjiAUB?vr8ewoU3j!~sx2
z&PMQc2Hw!D8j4i{b^Wl7YzX3(J{~?HvpLGi&nu)K|Kxtq-vK<})5ijEYZC2&PT+xn
zom>p6t{O$fFLC?w`66x8f+SIl{5DY3g$O~3K(inMw=`r+*{^hbTu{*1bt6=PP=H)?
z7LAd!08E9W=)-SV<YGYA;c5hbo21=pRf(-f;A5ZaGZHEe113Am1kv_TDlaMUrZfy(
zT3VY}kxlJM^vI`!!6?$>q4bz2FCw)`>!2rT4$vb{-h+>S-fHM!7v+~;kx;rt1F1jJ
z%UkFwKH4kY!vpj}pYEFIB}l=OVg^!xRPq9nsaS)<qEvF?wBy{e#mz5YB`OBSFM3LY
z&0~VjNh6hcmYC>cM>vWmsZ3|l7&*FFK=*hh;Ygr^oB?coo_^iawuXz4o8$V%N!{Ao
zaADN|hfPGp)QRmB1>P=5YFy?=2ZN(%<7GHM0vmOpLbnJc3R6?yjlGA!Bcu8Sa!Pk3
zqHZOB$OrTmzc5oqaRwan<z(1z*1=(l)v`kNK-ldbvUv#=$LcPP(O$}kgp*l0FIq3S
zP&29|6V5rj7mVoN!zAsKp9UY?I}Tp>#b{HLiF9Oy90!=+&@P}iKp9A=$mKZ*^DKy9
zbkYc7(wG@GzPQDa06Ub54iG1hfEJAdD2b9VT%ZkL2hm#}g;M&3Z%dA%4HrwnQyv8{
zZsf>O!{C_X4mUq3DJf>)GHTRtIQF=s7;ZAs5Y9I-`EDJI#{*0_9~46xYbd^|qejxC
z?M(0Otdy$<>Hq*h07*naRD=gM>~w-dD__*F5JqIB!#!(vKt;3lrZ295-)gD!f|LZN
z<9p`9bpw0Cj`~LU>5@&5my!%Gj2i@ru6rz1N~|Y5EHZAAq||N^zj`=9gFA%>Xvhd~
zlUQU{jzt&&c*zgMb<D&<I12-be|@k6R&K5(u&F!69J3_(oWlP*pniWLK3G#eF2$>U
z5ertLBh!r}*d!2Q5Xuk;l@Ll=2at;VAFGi9Waa=Wu;d_j;fYAl2nIHpJ12BOB-wZ1
z!TZ8F=bj38|K>rsX2zwkZtX^R`tiRpF>*aP!1xw&Y(Q><QZLdSarD73ai4J}$7gfD
zfTqTJRz7m_VK8yu@g{EG+yzimYxE%#D(Xlfl8*rreW0u)Dj|V{Fyf2yYLSJ-HN4^`
zAmq%%+)Nmrl>r&_=#e9kC~s<kix+Q%h7b?LsLW3?dQb0+G#J?<9kw;_JuDS%d%&c2
z52Sw1%(ny41tn_OQ4imo^Eouv((77v>Zl$FyWKl#JymwaQg@nLT=$j|sM2VgJ9z<x
zl~y#tMGvlk+D7?a@fPaBxBzP1GW3mE@5sdfdH%R3-_vlClSjx1Oj4Eulpszh94U>}
z3U-?SlSL@9079L>@UlYSoY(nS$0u4Lz+|^F67N3yjfZ6XvDnnq1U-8e!DpX*VW+c7
z0dlk&q5gsO&%gZ#UVdQ~+<xZ_=+Pt7=GK4y?Irl{i?iXE0>^49+i$c1gQFQ3Aj#MO
zh6SQeSRhe>H^3chcG&Ffot6p@jp_^ESJlBi>q_B*z6Ef6&m6c9^D8jWcxI0h*i_fZ
zf`K8KX)qgCG5)-HH<OWpk@;o)3*pGZ9LU7R+ls&X?^wMZM&T;Ng$OS~*_3Geq6s_j
zV;gtDyz&~jV`y(&smNfs<uwiPn>E{6p1wvS{Ki4OpagZ5H8wF_@9(aL9;nOD7E^#v
zW@@ioc-F98kj=o=ibD&snf-Mb?0j5S4S&K_nxFM6fP?b0p#XoWmtoLT(cBD!Fc_f~
zoX@cidte=>59|d4FgU4hYKB*KRKUNtl?$=H*JwM9ENpfZfyBuF+XD&@=?N*>snA^A
z1Wi@VKwBBB?pX@kXKjTEf8P&!49#ZZYgSjmq6@!b`P7_L*zb))pnhu|BxfW;M&C>*
zeR~@$|Mg<o6rFEF4@A@MWY&E@9}4@7%z?C&Bxr1Ig)f&^!Y`g(3zweQ7fwC6Cp`Ve
zR(SQ(oiMClCOmfaa9FXq4z7J{6`Vi04_tJ7F&-KNShB7fMwIk`SLT+&GjDEd!`j+a
zMN{`%&lv~@j>&~=?6=kREl^$8474Tj;47QqtuJ@Oej{?=wjU3KqTEzyXl#MmU+jj5
zXKrQ+uRggSoQA$3f33m3FQ>=RM}zzDF>BqndbkpOCDOeY4Tgy**Yx#@D){B!)<ITA
z3cPgNDA-=s1Q}^b(5C>mM!qeFyI<NUSR-De2_$}6awLvfqaZ&u8_Jt&pt7k324wVt
zhc~_nUsSAwYX_bH2jz{#u`V6znj2tl*-{*n--P{hN5JI+kB3e5JK<L={|!IscN831
zG#1|7xd@)$`mtrBSP?J+3Nem}X^{~+fK;?rC$ND3=R?FYL~kRv6#yuZAdpxU;IfFz
zohI%#4*#LpanPr@7en53+qLX^_)!PLoCv{KMrH<Fe98H+=U$^BH8mBgtE%CVhn|M@
z>o&nv*IkVN&}}$_Q*g3$@d|kAvFD(^u7Q18%pb_)1^OgGJ<fym_2ppVM7@|r0OKc&
zg;P$S0=@fiTQ_dl41c)$Q3D&t#i2(X0>vR;ux8_+LX))k48Vyo6_wM3-#0ytk@ZYV
zVdX5GxKps>5N=#<58!2h)BEH@p|K2pDFzEudgTG$Bk)y4Ez%@I|BO^N@vg)Gp}}zS
zI&?afD{(@mw7#whHehf<vil*uNLd(++&jFO1rfwkfcP5+_h!LGBwK_GuPe!$T$l~%
z=CUNG+#Bomb!9F52ZMl03<!?Ht&qbouprwgnAud{#IE^xrXv%1e}wg??UDON^kqQ=
z1r<2%zy-LCGZ_OaRigHlKPsA_Fxvs72u$fX@TC=HKtpLgyQbpcnVgmk196g}RI|2*
z1q&%zsTg2bd%@W7K(MS~Igp&m{}D{@6Z^4%B7#bdPLKzpX?HSV?2s&2wxI?m&s|X0
z&;keTkq6Tb><NojSF;K3*nJ9_rIYv0XXTZfY9Rv$gG)~63$%1!j)CWRY=4>zi*otc
zkf5qX6l<$HjnzJ>S6&(vVjx^v*~qRrJyLKINQR#r+lQ6!yJRQ}A{MW&0UC`?$3Xkc
zLwi91^3av)-q_R%dkoC7Y1y#70k)MjGJo{OfIv=r4n|*Ztbw<`+Rc59fy}f?MJNjx
z{SXY^Gw{Bn3GtYH3Rqwx^ZVrkpOHWzMX5Q^KeGt7H0;K4xDW%1EF81a;H*9eG8N;q
z2f@P1weafp`B2$h2gmdr4~G<tfiEgoKxsn-jLR7eXZAS=PA{H>V|hBvER}xE%SMWT
z!hq4(=1LM!jD4I2OLhPQOXMb=osl3ct_ldef|c=80Fa%Ng-=%`Lv3vx<mTq!KkI6N
zM*J}vDNztHe($l2cf<NkkeZeTeft$Ny+el&#(-iYeE!*2&`{q1dyU@%4nAyuPm$IN
zhOpR8dj3z(WI@CipMM35zWo6T3iI7W9_$`qH$OrW7D%L^laDUSF+aU9Xb6&;u|Y0d
zwi!Oel>tg)vvDa0({U(^(iO|Lz^_(sgYy?}fbXm8;Y*yD@4!`t4H%hGx_|vnR{p-4
zNBPfg*^Mh6_LUK$J2<Zgq~qO3lk*izH^bALb`cm(#K~PGFIxoO>-uJCCEnP{c;oP2
z;DYY9Ra;>x200WYY&VuHN8l=hNPpVM&ydVP{x!8YIN_jlXh9Z}^&QspmF*Sq()Kb&
zKDj8{yhlWbkEY>;PQPm`hwhf&&Q}t)y|xMJ@Rt?^6qHu{-(pyN?Lu#L__K7ulux1T
z3*HU|2le!()tH2OAli1n_VHEl!@3$af$hRcmC{}qT+Clqg}aQcFlHbR91q%)4`Oq$
zjSs*HkkZ06)o{jdmSE6P#mepd<*IvxV1n%Z?eiO$*;KFXWet#v0malwg?M%VU@fjF
zJooN)`0rePZ=bM#AzQ^DhWSe?VH(~S>vq^zB!2(m2DtSvYne>v*L6>>hQ;e@AsvH-
z-Bo<z8jHb&NVK|h*6)_WSGZC^>3~r<ZU(3W(egk-9!<PQ6tO`5*hao3@Yc?6VQt-Z
z7Eq9^U$1!ymep*=A5*EYy@9Wuj_A=BF-dUmx>vDZw7~iOk04U`!`hj+(rWhsLx?XH
zOjx!E3k8~8iN+$4vIbDX5xt|x{>3(5_IF}9tqff-{~LH?*1JsYpYDGW8X6j4J)V#F
z)h)kea%EaZBz;kEK<Vz^JOsbH^8vW=+S}oW@0TK95<K*WCt>xf^^lG~v@0rj`wbgD
zgwe}i{0R}%;_!=1LwP!QnTcB=6!276)xgYG-hkV0{+*L7`m&;e)=%{4#rbm368x1I
z5QtQU<zD#9J5t()6D;-nUB-$6oq3?u1Dcp=J7A*`Fkm1LRpwGpB&lwEA7fQyDF!2y
zmKkR_`led}kIELeBsYYDgk>1WOvCLBk!ZW*iP8O8JqRXNP;&4Wxk&YRb5Ux<(V!8%
zK)+bT>J6>b+=m~L`lLtprJ!xgt2qDA(tzC^8!70)%Eoe>fUr$zMT1gGkA%gzZRw6K
zuPYl@k^Ve=6q_`uvJ^N_qRF%c^NTQ0m^eHK#^JWsP~5hvsc(i=xV3TO{zZ&#8U9+Q
zw0u(?Ta{pij`l@WvTjqCb+xz(L#Y9;O}J!8s{;dj^B+L8LU7MTLl~aEdgi6V#9{mg
z2CY<3TDGAU1{?GY;PFMie&)K7E??(J_ew=g6Wb~h0bNFVwD%EjKMxZOFim1S+t9*;
znFf51LKD8LAO(NX(+b1GBY$R%buB!&%u3-t+1XeH@9tiR+u9RhTYVXPRmrz*WEZ=v
zU`YJ(I6FaT#$#r<iCm5WqzffOxTA>kvcIo{=v#hyjk#5D{!h<_%*;$E?$-xSJn2|?
zWA^`;3L%>n43*j0d=-PXEjDe~#9T=E>grlN`_Kb!z5QA?=@SpFa8Sz1;yz;q`3r*x
z5zNV8Ip2(1<R82@7bYKjI7~k72=-a>!*Y21;b&zsW!`DOl1Kvjdrl&ZHcLzJJ8(i3
zpGGV<8J&Q(E-0xcL#dybDr=2^fzC$IqnskCjHm6BAZa%?Af<uEcE>>6dZDxn10Io7
zwg_CL>+I4hT=KJ)C6B=s6$*yF#g&C=3)jL6+k>5P*lpPJO+^jdvSN$*xeuRCNpy<k
z;91Nz#pCRlm1;(n2cl{BvybS_Cbm^u>R|FMi{Q1-_%ClE_ia2YK<S!O`ZK!E7FV$H
zLfrPCw8tR+Yg(*YFkm}=dDh*Se1e*`qr8EUuEe0})@Rq6pa1*EdORb-Pt_0X&Cfv$
z=*6#*RGf8~<?CaA@g2;Z$5-!Uo9H$QI0VXUEFbiY1p6WEqvfc=v23hcRJjh$T=)mv
z%AIG^Rg%$@1rY=+&M1JRiuSVMso+@$w(?+M*>uVR01GBF6O?1DoQxN`sP1fHmdFU_
zOoXQG0Xp<ZlYPGuT4lkx4YxIN^Q|9_3@CjOUu_L<ciI{$EGpnwtPjl#G}+V2!RAd{
z;kqk+2_Ju8_ZbmW&_SuFXQ2`FkW@@~v2cc5j)7NSo&&$U`7U+_gtkle7&{6E4;{#{
z#BPW%$Rl4o=-c#XZ7Bv8^h=x$4PG;#2<Xf}kVH2aor~BPw<G?9hbiCPRfSs~8Sp9|
zI{X~rly;)*;dq^a=Q0-IVa`wRAY(N~GgI&|XEyyrz|;$a5IW#ljgi_XWt?v^Ze>vD
zaJaDzF}IBWN?;6ee3Aa^2h!dp*G&Nxr9#}|IW#{DPQ~*cLDH94ze`H+&`eGyuEsRM
zR(uj<KYT)EEuQ;WQOgIbAadH1CUZa!DEY}CNX_AaRVw}}8-CkpXu^}}n{Z&&sq=bZ
z>n`30^RrXnq)9zt>H&PELDcAdJn(n(*#luT_5n(7;(<d-^Ox{|f>tVK-MJ^^;UV1)
zpJ*WR7)YJAf4Hy$&Of>jJ79YJz6G#(S0hXsor_x?b?_HFOnmjp07vg#z|K<aX#`Uw
zqkqqI_|cKQAv=@*V9LXlof)T>KxIucY%o^q$k$WR*C!sp&z?ASM+!)s^xkE4Wv%x{
z5T~1_w6T(jEJ(}31DT`Y<lfdke+urV|8nT*4F9L~v*GFiC$i6?s&zPqBcEhENtTL?
z$NZvz!i<_Q?>Ja#nq>&EWEnZSP?8n!2#Ld0c#eVJ-}y)Q{R6*(ci#E{N=o{{*l}av
z=IOsSu-+GX^Cg{&7&xc|e)XH1;j0DT!tfD8QO<|3b0@zqXw~A7!w!Ih54C(IBoa-2
zK^|Or&BgG;cS~W>!o_%9#?S(H`PCP4+_#APei{7wuA5-N{I8*OM=7p+)IfShI<(TN
zp{Sn_E?qrQo`?jVk&x^%v(#p<mGS}P1e{3e$qPzyTQY$3CEghJ(1uc2iQ5ppa7q71
z7!2%*fke5qdhp`5GCai71Y>c+{W0R{>_IWoQvT%LeA3RwK!VEW_btSgk|wwx&rZ-@
z9UXe4)sEM2mEco6GvSqlE#7#;)7W9?QPYp4pkx8ADExo{&fv^+xMfHmJb=WPu4GxF
zoyZ?_k5HnmoQKFxEKkFFTvAd56Z5j#<k3>sela&G*f(}o)?tyl2kw{mJ$(T5I<A=U
zCgY(xDwmu$$WxZ6zbAo4B+LWRwEO?Q-VN)v*8v?ooQ@NoSmqbT)#K9&tGDo=ot{wm
zY9-(Mt;cPzhhEtPRrsVsGH&mY3`$~aMDVxuHJZ9RZEL~N*;tXr_d(RaW3#s4ecTF1
zO(=l#j>4zM`e(wXo%OH<gRk%LDHU3n-4~yB*+$!Xn22@|u2Rt9$)hLaGZ>wPpfbH@
z;$8IhdOS}-zP|p{{!oigiUdx6gRCJW$YD#qAb^I8!OFO{;zTY~d{u$xII1?npv>NI
z!;q74tmExZq(AO=D6Z5N0j*Yiu=@viar>w2$JWh*Pem-rrH@rB%1T8GK{+<@izR;B
z^BNYN#B9m3a!feNp}I??N`3*Pz=6`juYZ7HctDbZ11?8Ucwe7-^si7_x{Ix79D4YH
zP~5jSRF+r5m-D}cty}Pn2?h#hpL+__)$=W0S<;KozXog9tY<4Cha5hM9oiH|zxXf0
zZGeJ;d<;Yk95UzS<-$~~+fOe#m&vBB4LZ;nc50XZwULXHc0EosvAoxTcysX(;tmWN
zXuBldL@!e*##I7Z(TK&KX!X-m7-V*|=R2sA(}7j8cP9oxbVel6>4|3_gexwZk!Uqq
zeh2eFEbUHDFHn~(GY$X-snR(|^uj}d)hu|p_u?T?T$m0|%-#Yoe3<xcJ1_eJ)m=H`
zSQ0HXPI6c%!Bqx2@3eVm13UjDD2ofzpbFoqQe9^S1QxHLGOiLr?Q4kuS?ncmSu*C)
zr|*ZWFTGI$xuwwm)SxAJK8Z`Dl$D}?3M+ExOa%U)hbnw(Lr%elE~HWrIzea+vxWYb
zgk8U^(a1~8R+e%}@YvH2z%`fMVlr8H6Xdc-{11yDw2~B-&CSb!y!?DzDcFVEB7C))
z5cC8HrOHYkaI=E>g<eH}^0OR9+qj#^q$U)#LoWXC%*)NiK&6zQy@<eL3c$?6_`f!;
zHU8Izx>Ips?XsSz`ZX>a@0Tauc=(;NTd?zQX`>fMk;`MXojR-79&y$oQDx8l;zTLb
zayx_vVrh5r1VJ<vxZs##xN@3x=84|5Fl)Yh-#;3e@zTapcW<3E@Z+jtsbdS$7|6Hn
z<|`30Ki%ibab7~i;%ixlS3bxY3EI|B1`#Bbq9#g4Kv6|25o9;35zA1)te*v8V8<8A
zB5_i1LIezCQ1UYkhE9gWyg@J18RRx*!A0vB^!Mg${uG9w_2ef4({P>%Mk^%qYb8FF
zQH?9q&I6w60D|){ZSr{#Q3<<fR+3Sb<yBBwQH{04w)06ckBdx+w1DjrNVtsbq5#Xy
zowI_`yqu?V)=*om@<3a)`>&r{3;T`Cg)Dp;VKYv)^!TLw>s)19qG5sRP9wU{&Fw}z
zAdaH5PM&B_gi`{a>pV^LkP|78NW#?!Pnm8LID{BTALC>h4p%}<l$CJ=CxozUpq#0I
z^ANohOc2nfRWKVsRz#jRX8n)zOWzJs3quH-P|GF<*g^<yK|pqjx(Qr_tFVWW*$Q?>
z70PTm71GY`E}1-L#zo^FqPWO4AgBktT^>|I`_s`fuTI_118vprU*on0z4h{s_$J7g
zKE}gf(h`4rc|CC5#e@*p(C8S5TFIdVk`Zo%8{%&)ZEbiZ8qe7O)R3leFIpFznAw2n
z9u)=3jd4g}6R#8Io~IcFo1iU;R!-s<K)li<`^Z!GdQR+uRN`ieY1_b=h*n822n_;S
zi7+R3feUm+0lo^ngv7+;CCmlafrQH?(F2UW!P-~kqnDyNv<I{Yx{U|ib5ICXcMEkx
zqERDp<G{vWA02?-YtCYD?-A0A&C-Yzf(U~J--(#15yYI$Dj5<P0Kepw0T!^hD9y3m
zvPG8Rf_l><DYIPG>1OwUkgXml1FS>~T}mWpRHFoxt|G72ueUbTeu)V6cWXp;O`tuX
zJ<!=bAm&-cU_dB0SPf0I8^X}a_VUGq6pz8eDXnJ4@Dz8Z3{|T^3Pwa<oSMElw}OLg
zW=OSs&tOE<)ghScLLhFRn0hHg$w5mXfpVfFomU`wSCWOfkZJ(cPhpmt*ai)*j41Vr
zgw1*W1#+19_)}`E_JH<)_CN#=&<G!4lvkpaK%vVQDTuh<fTT31vegKSJN}$GkWz+{
zxT;DVCV#U4z?2bTTxN70^09KB!2~IkbO`-i5_g_Ws)APV$fBGFEM*#HK7w4qW3xp7
z@oM@?g2`Dop8;_rWHwt~2NE`S*bC%G`D4fGlJ<c1fc5}-KrtalF$TxxLWNFCkT23A
zqg)_ToQk5ZP$0q90L!crqb)blUg9wG+ryxUJQANXfbi!<%|xI`E<P7PVxqt$!mGF?
zYEPXu8Z3C2<|K2KEk0qi1#uEfu45>{K?S|F;qaEX8y$qYs6C)Ppgj<V2WZZXW#IAU
zvm@=L;6}5_g5I3voJD*^#84T*LWVMDunf~eD62$RLCnzn%R%HQN`#oDy3msyG^s0O
z3F)#<Q-CR$_z@}*x%gZFVLKuO&J-MbCZZ@Mff8sLA)zTt?+>9wuS=jROK1kyD-z5N
z{LASa38k~z1KI=H1Ku8xCKMu~q61{`dSKMVjK>FM$V}h`2gT60HT=vq2Vu&X1(vfQ
z0xqs35c3ouNFd5eMIy2i3yg@KJ{DNcd4OdS&g&qgq75Vf?21#a4QUq_Z7HHC7XdSZ
zsd1r%atDH3l!7l(6v2cbldma7`Nen009F2^Q;rAuLo_pPxr&i4U$%<jM0wPh5uFN0
zK3joxn1*$nj&-6k)j{M%{Y1H|<EWmZt*L=Up04B@;fL<#7v1js-sp<$9%`Sz8U2Je
z3hOVJr<;bx7kc&fbfe61S0XM+!eJSSM~%j@=O&(Kd?zEHQ6}8=n5SRS0>{cIhv9BS
zoREop*WY*rw`KHjmKV01c=B;@9pb1=S9(3Pcs;hri}H0hpbWHZ<?=N!<)mZa>gz9I
zc8?e}%*?M`u^OgKm2pGin(Hs)e26<?>alRm^vhX!<f!3hp7@kFRLF4n-!vH?*2(0<
z{K^$;48BWjGO4mFm!nLq&$TnKewc`l@>GWv%U9ul=;SymUpwP+I05TKA4(!G%Gb`g
zl-B`eo`^J}JQDqR-3?S9YzLG%bsG8FXm@HOBTsE~5^D$E4@Qq3iMY#|-&c^#X~&?P
zOIdm3=wW6)C=RO&#CI*qpuFG{WwMjoOm?ne|DE*O8RRqaC-PyQlrx{P`ti2CcKRiz
zFUT)%zwti)+xir?h(rI;mwe|;?edCjrx9&gRym<9^>-#+fnFEfnJT1h4dj9D-0q>&
zT`|ZgKt@|AFbWV6dw{u|fJjd=M5tboO}|9VJ$+ARqblOUmcOmnehY9+S93W=WN;cZ
z-tNdD`0b^Swl5q>h9o7?TUB|b9)1E}1%1V>7PU-hL5)==T;4bSeY%~@DA|D)H@!O|
zDgM(0!J2_yWp1pDDeUo-;Xpk6#P4Co)xU&{^i*iVw@NqQzh_V_wRQQe4f2cpv07E<
zv<I{Yv<DL40mZ-_h8AD3u_L)@3V!;PD<)b-q@dx<3H&xEHe(c*Y_g$LCQt=TB2FNR
z^sC&3lx29JIltuyJDE|k15K&)$frQbSCb$@M({)+Gtu-vQFuK~5X+DpW%5AKi^%v#
z$;E*2hezJB+YRI4k9M<1E7l&+9_VHspt%MIqL{`agEtW#6H{OiyOb}WN}z3?^|cvm
zD=`0xI;r`Qo>-*S2_^w2N4q37w@Ktw!em-JLKY`8O7ySIDba-mHG+yk%`Y|7L@P28
zI1o(~DfnM?=|9S<RuB|IJwfc%=p>Ws;E}r2iUd{DyQ&@@&|vKW?E&q9M0g<37;a29
ziO_G88ND8wIF#dQ^rCE*#8Yrv#4S|XDJx<VxeXu}BIikgsl;%A4aP;-K}L!Bkt{a_
zMAqj?5ljXhjC4-?cH0~Ze8losqx-)iz0<Eq_|)IwDP7ba&>qkpXk!o1oD*@7QV=OX
zWVr{JSBj97JoWi<b6$glPePu8A{fF&CFa}PCV>%daO+13gNRM)l$VGj^OHo0K`2l#
zx<KOH5#m?9LW~d>(^V)mnAzEum;||*cu<0_Lmi|>WqPL!Bpg0-*IYxi2eb#Y2ReWU
zf{#@+JUgfrpg>jf<>N?S5>jH!8WHJ~1`$^x68cAWk%t;0@jzKdF*!n>om!}{LoHUy
zDRn3q1;`9sgcyMkWj|$t#(8zhFz^IU#Y3`k@*w3TzDV8`h|syh!I%wRyEZPiLw=LJ
z;?p4w)JAC!Xb)%)I6T1Shgc>Fha9;WzqrT}l#_;R1mz=(adN~}cFlJ-fUV#=SGczr
z?7YHAC6obq#VPAaBO_Q)=1I-f3ADHhBUIN2G}Lx-AVK7w$rs7F<i0>vQB}IbKK>b?
zexAP32<-vw0quc~<N-FGMI6*T2ozui$X#7uBKLG^3P8S;6kM#9_<g8tbR?s-l^*>J
zJIWvn&>%LGnU*p&tzhUgRhk(_XfKhu`1@IGHAtd(7O9;K1`P+}qo1wKR7o4By<|ff
z`m9Gy?bvWj<ev1@6v)g-g~p~9sB37#M^!znliJtI3VQtW_8aeDZl@~O)HOmg$rJTA
zWOTR{39>6d{k-a};URi}UP7f)_wzt^Zudmhoekw4<GIztJO~tE1;`Q;Fz1v(FRJ2m
zHIBfJL72Z7IiTP~k*R(T%XXT1Gs7&Ql7O(QGZ;bq3HU-So{+-SBe+bAL4y~fk<gTt
ziWVK^==~AwkJEV4*|}mWk)E_vF|9jWSP~h)2(c0&yGy{BBvS?p%_QL=WOMU!;Mgfg
z!MO2zMkS5j!gU<-5ifmGQYeCJ|J0|rx2G-rOZvj0M;yfL9Wbb*{f!OT0(u)?*eRob
zCM4lwNji004<w@9`xd1sU$NUWFBOUl(mkC~l$+}M5$Z`C0wR{W=VzrrpZv67+8txN
zmtTSibBJ=Y_!790;%%0;$wHE<3MO)rGoc_Q%c2s$R4s^St|%>sy`R97Ktk9@3@X_n
zCaH-sGd7eL-;}A7O*)n_+0Bd{kEOi)JSgm0XoEYcc>qCBdlGcwYRAS_B3X1WlD|YO
zHW@OP+iLV40vX(a4E?ZW-+sk##@W+g-P#TC-J->^U9P-r%h8h$gNgf%H)%fo_;aYK
zsWr=Oo!Mu<32^b{7huEi=<eOOKZO6j__}FE&z?o_tGjMC%Wutj7dEcnWR|;Q=AgMp
zKys$lrE1sLz}KhGW3K3T_5c`k`A|sB!$|{|##Y_C6t@0%GxR*V4~)5QoXcHnA6^NY
zo?GXFYe2{Iz`)+=aMdaOVbbV4ShleSF8|X?)5y~f=?NE4=?l3%QmEPCp;tD+>+^Op
z{JZy#gES+ktf+2+C*RltbLQ`6xKSlN;7?Z#hphBu#`lN+Y=k$y*k#J?2$_PMRQShD
zqaZJv_xasbP4M`v&G61wWz4*{@7@bC(SDIOme#}h_bg+@QxCTL<&Up&zZ^a;4}SBL
z!GguSJ~d}6{QJWlUh|+y7hQ%z1GZscXOn+|+A(a^pT_N+luY=;i1VR1BcD-huHOxR
z-})geC|||O&+T~)<fis8xtCRMf?HQT&&r1t>;V__Jpy{C=ixGW3;c28Y?xcN6vk%{
zhC7F!WAcd1V;kOr_jZ3Tiqe%VaR)?<z(koDlTWU(2e(OU#w)FMIS)O052U8@cCW6k
zhMBL-fq8T1n|wrVCgD#XWj1<b^dU9HIx`di(rScIM|iu{28UCbQ;@+&?~iaME6B9t
ztWn>|k)X0&y`|*2XJ3Gq{{1Ta`nR`0j~<y8q8)M>nHgpfQC?O7`2~4!%<)IUqHlj-
z@3<$E4mfBZX4yAiErOT+^(xf1W6+Z*7tNXZcGRLb|7$&L#X*r$OAYQNQo=?bI(;OR
z{%;$s{=;$@e%ojme#;ox@zyrj{pn8l`Yax75NWStieb=Y!=Uu-tyI*h9Xt?iyFWdB
z6jWkcSJyQ|sx<h}fOgf%{o#Xe%ivG1ZiXArDuL;zm%w}9>_*xaco_T1+#f1fpm6Jt
z2Eg^FmcUzImO*oKEByZAA+V#Y0j58>8t(h~P`K%=0r1hHGRBukmqb%{IvD@O@=EyU
zdpn?_rildrH=Hp5-u<TB+?Rg&<5HM4p9fC0SZ7M6Ulx|34>rRMXO_VAr*Xf`Us?%2
zy`O>&K2jbzE+2k&d@=fr2PaH`^hFbn*O<!4q9Ax<);lPR|4AwwSuT*?E$~I<N_cba
zw@};M0GF5G|Jo>-0za#G9Gck~34niY`55MwFJ=7oEsg9-(yuHz9^T&dExfpG9-P<r
zP`G};N$_RGYFJvc87^P?4ASvwbYjj>xNN|&@MR?rP9oIQVJ8;JF-(-m;8mVw4H9B}
zYtDOg@lHa7VcW|uz6OgH{($mZ;k=)m184o{beKQyOK54qF^`*%vPhp5NHTkb29rhr
z>{n73ZKBnPRC8OygF6br(yeR?V=&VfCOC2bMm#4c8}5DZ4xp_L`X?)oJn$4WH8sK2
z(=Ub5dyHVw9F>>+uneAf_*tl{t7D&*W@GZPY-BkvzD%6-?|$IduzOb-q@|@n5iT_?
z`21`5+n@i%_$Vm2=+g6H&%H)7oz+#<@W_KtvlWvudyaw&FF6<Tafzz2u@UBe^f?O(
zCLOddTZ!1Pek0s{$AfUzk57f8k3AfYKISmkfU6F_M}6t(d^vW)#JymTv7=ztt8c;k
z|NGcsb>}Y5jv<g}C~bhc4YknPWZfwR2Ngk5S~9G|NujB-3D!Qm3VI#e7kW+Z1KVET
z0<~*uOh*+R-V18iRzv-^dK0EIZR>$(+x@!7R>AU3weaM1cwbAS&jF)z*ownnFet3T
zAmfSITi~b(1#rap0=ByF`sdaP!-wCN!$D*6*cJi(tKwdHY4GUG%}|aj6~%?=xC9O`
zd19ftnvp1vL{s;j6-{v0^BYW4{_);+xcB0rFsdXImf<}>X=i04Y{Hd@CTUnZU=;Vu
zvxZ-uoWuQc__zXibHQ#{$ND}W@elq{F09*82iwc}L~JSxF(cL`-gq4Y31bB|lK6_I
zTKMbc4^6UJrC-CO{E;vqy$IIT<H`x9@}?RnZK!}|b{LYAj>#^8%#?I^z4S|{ZK;P>
zwto&&d+iGoatFiw@|Ccy!3vo6%Nq`ht2ROz%CUY4b2;+2VqUY*+>JQ7V}|7gz#^d>
zttb=58nx_rRx$|a^4TY!o3!72y%5HZ+XD&<3t;C??9)sImn5%#*d#I<3F50*qVvd7
ze3Xi-dnwZWXBc8}ICWYWTTYOP7g3o=h7ed2$}&>8WJknX>e;IZXp*O`fl+w=VW0gc
zFp<MX3}KV_yiXTEeSHIrn=lp*IsCwg>b&@p@hnAVW+wFO-xt!-)0mt|2k*xM3Mx<#
zF@Eo{MqscBQZd+|?U&r#9JmJmyBh@&YgVnpNU{}<!a#unhT^_`m>hyrTE3Jo)%NUN
z1Qh6O+qwg4YwH-Ux~hhiE6OWbxhs9ea`0@(wIkr*&yR*l?;i#Q2NyASH0|PpU>Z&i
zl+uj-<cxmym8Ue^N6*<K4>rGG4bF@~f3>LxqHT8yB2;O2C7(U>dhmtM{49R$TgdwX
z@l2gm2)Ca*2yQr|1eR>5fi1flU|_EdCT=NC##fxwA8P7bpb=Lo2K4eiOQF&q3oP2Y
z%Q}w0)dM=wzH&1L(gxzPsr}&Hd&k49yT-z#F*ytx*)M#sF3d@R(F3yJl~4GJ24fb2
zCB+JmgvBfoL?9wG9kw(lY#(|RYGUqCXuyADwF$R4M7nC=6nJ_3jqvoC%VCe~0SsK#
z%==1q3UA}=R6YjuO3f2&>`GfF`{oUUH+Oz*{E$~qU^XVdg2C=3h5mafB`>^6^udQr
zf}dV=9-MRTnK-Ad=Rt%?NRsg5SOGE7&Wu4Gl>w3rnrBn-X$@r(vXw|XkVr+M6%J>j
z>bRkJHp596R=EZDzHYeYc6j-PnM~wf#^K8c?|BqfuUw12=+mIGf=|A~M-GjsHWDA{
z`^AhqVd>)KOct#`P}=MN+4~N_s;cDgNv|X%fsoK42_Pcs+ORiJ1bZ**U)O>PD$Ty?
zs=My0Yj<t??ON7#*WI<O1uWRmRk5KW9Rh?NNCGK@^nCN1d(Um}-uLc%d4T}$B=6l*
zX6DSyIq#mibIKjLmt6mF&m-(zc!+Lbp636&h!;tY660dS`i%sa-lrdZE^vn(c?e}>
zXp4s$8=54qK{p!G($lG_shRF$THk#2y_9|S$rqCT?wcPZy*qt{yYOtybF1j*3Exxc
z9~Oy6V#wWli#qDqUE5mUOvSekqugV9Qpr8qLfk~h0<}ID^_TS%o8I2AJE?J(lO^1C
z_Yx2WMtxHo-Nfr-jvSFiw_VszK(jK;8y>t6hjUpnd#pbFsandh_5cA3Ezdln2i^JN
zD%r}GZNU?OPWTE}cHC6)*}o{0#vPnXPjlaeQx$oCXAi~Xr%LJJ*VeH|qMdHNfcrNG
zr58-s9Ko{RdV!`FO+F0M+E9HCd*`sO1YQbTa2v^O0FflxwO5IQaTPr4u`jzUO5=5L
z`3KX}>pn2N4}ahI8Qrk#MS5uUTh!d%Lf7{_NvN)AsHE!VZS<>x<7i}Nf4Z`_Hh?R`
zLREcy&InmQ@pX;4-bR&0e$`t`zgX#57h76YV1+T_I>7J|!}vjXID5hq2~*t8pn+*V
ziI6m{$N+YJtmV!)!@?WkHt;(^gQYbd&5E5K2`Lf7NQ1P}(tfeloDRlS6;(Xd(8|B4
z(&a0K;(&pD#dC1$Z>Grrj!X>x2<hqOq8!O^e8J-o3J;zEyr867_Y7d_A)O5ZSZbI;
zQ41jvZ{bBz`MTEuo{ULTt~6@Q%IZdSJpF-?nx<LJX*z$q<2ndK@F+yqK367GYUXa`
zsfi{U{^-7xIgItmhQ#8V=F<RPJhvAwtgM}1O>GS=)Wj}dYv^@GZ`#5O@!I$aG!}Lb
z4cz%c8C^N9fbO|uAT8p>w+(DqR8+SZ!rlI&)@ROV1M`}b3+amm)wGp=p9sIdY#@C&
zcMHKYfhm*fZJLL}K;8)vb$_!~J)l<#J#^I|Uc*sMuYO)(6v2={_-Vy9+QjQU?vrVc
zG%+N8qxABB7QOIPi8Y)uDv!QdQcF#iX+mpx*l`#JZUWc{g#<95L9QS<o9-<-pFIaZ
z((En#0HK$DQ1z3<O1GC&6&nus7F|I7Qu7Fg#2?DupmXyNqdNzlOW)Nkr&^vS+1jGr
za}{w+cYL~a0UIH$%(8!;6u#%xN(ynsumeGX1s3Z$4Di=KzbN>}jX8!+KkH<gKW_nT
zD&K69<Uv=_0eKY<r0J;KEvb-Q$}r$#r-q9I!38=n%Oq{az^v<H%RqF=>98STsoGWr
zrVbDac^Ux$(*dJT<W>DVu&-OYf&Os!!*tepr|@*bQBtnHTJ*`pT%H=K*LOkq!IQU~
zDI)q+4g6SLo0HpJ)={7cmK)YoAYdKDTd%(-aeOs4Hd29ZWE2k>EcsXifv|a#d6STg
z-TW(@g=bDxwDR0ALTdkXF(kI~d^kP`DSYESaK;f-zudfeWFL?tJ37|=eYL>EzIL7l
zI@0b=uD|8Qi1;92i{yXq*o#(d)TRZku<w1hMGT2Ud1`C+&zff<mAw=XzPgUGczY#0
z7Hc=#4Noh6G~&3IL3Xcunp+(`S*E8amxz&c*Gpw?Ad*+NT{D9E<)?@tVbe?ZB>MO5
ztd|X@UiK@>kex37o~;=p0faFcg~Mn70ec39ym#N36-d&vo_5Mk$fWy<E~Fo7SJGeB
zeQYOa!K>%B5C}aJvuO=g(h^=&`P)^mN?!NG40?X}B%Tt%y+K1NN-K~Z9axYlLFDYX
zuqFi+<NEZd*J4Wxq{fTM5XUt9Z|8g`hQ!_@_7X!v;TXg%n24I?S^=c)NPrPxUmKxO
z6X!t?!cIO6P%Z$j-3-!8frO8P>4*&p&<Yk(Qj+QB+ow<=pS6InfTt6%CISHqF)_7p
z*pZ_oZT+gKsFYn2lO|sw+ehd9FrO+av;im>o|T4*!??iW$bNjr1GZ{@|ILq7R5Fm>
zpYbux{q83^>EzMWr*Cf>b@+i|B<#J<Fxt3&6TST6zv=vo&ysZ)4?KF0EEomNPj<7#
zluA$0xTXzCCl~`2vo=vGZ`~`pb(l<3)bJA}LJn^OtXo)1@hR~%{PBHds-w#C^w#%R
z1E{sGnW~*`+-NWtqtU4v$l<AoTs{vXo!b^Sv?4w$1Pc-2Ss2A0sl{uzQwpypzyHdC
zGS%_b!Wv$Xm`3{-XV5J6UZpYKb-aBPVG(;D%C|IAMNKn5iMKI55(5J+{*QR~M@K@a
zdseu#Gg9N}uhU9om&ud7Xt=0Q^Q^9~Y^0uS9Kaa(gcp$(<|Wfq-pv6Sek`q%Y7Sw&
zEMdJQTlKQ2#$e&1WAkN!>RiLvcHtg3b3NM<HE6g-LIAoJyJV)tC)54K7f=&VTl};9
zOX{7HBh_u@#g*N8+h<970nM#lK|PYPcpBqanWk9YpiNm0=k*e+8!9L%E`g@@KUt<a
z7H(T>usgoT{#4miOUvpvD)FQYqJovk11MPasNzgjMLme4Sk>LHe_tvYQbgZ=GnX*V
zoq5iwf>l<w#>5tH1Y;?>3fY7(VhRKqLBI@nYXpORa#Di1w#8b=aWN(wM78>?wK|YE
zDbpG*AgIqJ+yAZ&H{`(T&75u9>Zw0ZXTSqdTT@5he*FVAHZ;<S<BpTXj_3dKEW!ds
zG=w$0^3rQ`(Iw~7z`_0LNIvWdY`^mN*Fxf1X&|mV6wf~KJWaWIBK2So2aFd?r&L$h
z$W#Z`Z=A_zUL0`Heg^uy9~Owg^ZcJ*re96C$S@+XBLlln_N0LMV!x}{lXFw3=$2vf
zfsWc++i3Z{i+TD&Gamb~o4OmX*hgsPt#b3P<~1dH2aiulpzb`sy#C*oAEH3UzIKKN
z!fAK#hpCJ4+<q!NH;s2O&8ZY`!o{QWX~e(`DXMR5rKwMs%IUh9>G5<mFQlA!ie^C6
z@)P^ZA8(?cS886WJ9*0Ev57_W?!6-f_u<#qhQ0MO+<O)(g6w`hGJ^_IjWZ;k=0(OT
z{PyM5YzVdRR@c7rK|U5?KJ+R-kL%MHUU~s+3VUA;;GG?Bd};N7;>QwPqR<ea&cO|k
zN1T&R9z*Z)Hb}Q(4blAWmD1ffL*mgPmly@VUGW<4)~KWD1GK>v1x>v5^FdxKft?-*
zr}j8Vc6cCO)m%q+uJ{+%iCX!1XErX5${tRyZ2Cgd+Lt+aSv8<xSipitt(Z>0I2t?d
zczp{fQw>5GR8skPf>X~JCte6ps^_upgZDn76{Rb+CK7yxlu=x-H_k!SkyIQxx%2=N
zaA*bFJu#&rRVgC+RilM(oEBmY_LQ|m#f?R`Dnq}z)q|pt@7h3>Pe1oCU31wqos|Cz
zPN(d_I~_2sVGT0v!GvL8gcBmgLmk+LiuDhh$}426r>YkU>zSX&4G~Y3?D@bN3KdX>
z9UREV_Ru{ogxl`$HsIt+{19aeC@(Ox2269bH@8uv#f57vkHx!&2EuLkP+a%rT^P-5
zSi;j_4VYpq<efTLDuvw|&VZX%|DGwdj-T+Y+b5lHNQb^Px?u(8J;nFBi4olE0x990
z2P_|ZBk+4z!v-~WhFOEFUTlIOp>S*kRx(;#FAf1^$Fl(Af$xcD|47$gbBn-OicFjk
znJAX`Uhp{*@HXTobrbF@T5wi~l0zfclRXu!y#Areu{Oe4nN-R5X48}~ArKP-gzM9&
z+v~7HG6gx)!Bq%)^vU1Tlu5VgC^{VnIVBsi(RXwCP(r-NLbiMgris9-7PwPlFN1r1
zdPRI;923pV4iN(i#-}uXrv_foh2M%ZV1aK#V@p84bHdruOb4Wr*vpZ^pWi)r7u|8=
zT?Pp1t>3P{Z^Ovt#h#Y9E$YITt=vxni!Gf-1n_EW!!saMU6JBRoouwY87}Z#z_@S=
zDBHN9+^uMj$n*PTrj&t2lGZaJRKB`4@M61I==vH6x7|ZYgcBXz0tVJ~y2r|`9Ai(}
zCU;ybd^GM=ie5Bj$0AAXObA8Yes$H0j1YFXa8i+@^BM_0OF;$ybWBLZRKOxh^GpbR
zbW(+U-P~+W<5;pIh@$mjW@x8jc#X=T`pA1TKeE)VL*wEwfB+=fFd#NpI&1(-EfTe)
zE!6D*;6NY0QHBvPi}oy0JFJ<45rJvMV8>zmsa+_#0K&`R7Lbj)oqDzz5+1m2^kR8?
zfCl_dYwQ84*rP=3>h0c{_o-+a5)pSA8JnFqYsvH`8KT$~QOA*|eI6X%eaAE;03SdS
z83-X7AOH`Pj02%G5~05Xsf5DO*wXZ-ST%8iGwrq5(s<N&F(^P=tIe#%jA=fUKt4<e
zd(6V0B`Pp3L@<`iaoBbu0Vx^t19J5YXFUpz^EG2ZWdvS<s@Ostz86u37fqDM!k(!C
zxVU3s&(lCxYIoe1oS)8Y5ln4#ji7GRR&Lz#Eaf4JEs$o^g7f&(_nG-&#Vka0JlCAS
zOdqvGGBRNhH~*v(A>&O8QyW2pH>%M;6~1OdXbAWYf~ru0UlkF{6^kLgrZfy<ZWUW-
z7;r8Tuf>)C72`ywt*YQzyjX~7Af|zs26nCnV)r43{xRs<lwwObfGtVJ3;W@pM+PtI
z0c@Zu*G!!Ulm!dHa0BoZuorha0*ZswYaQ4Fst7kjMp3TJr9LZ{);Owgrjh4D0@)!0
zSbz}`>HsR#DV_!ALeCI2hzZ7X8*V%URr6M$+>}5(5+UfuienmxX&|P74r@SeY)r-N
z+F|0mBLVY1&C=NtQI$578{4(!fJ|iAGwms`9GDYTL3S81?!l@PyVWVihFgI>Pm#bi
zoFLu^-mT#$giBk|42GxpR<OAG<Hm{+i^nt&(?CoE9vV<L8MmtkN-R5=25e)mE#ZyD
zU_K#r8mhG{Bpqu4T<N)HT4-=I5QK9AGwn#$6j+N=P*O&Rq)yG1C}+Z$P-VhD7K1`?
z>&Fz#25M#p#0+nQA7e%F5J1H{L-+veh<F4y!_&6d(gQD+9n(Ne12GM_Y9Pq{#uYx6
z8G!~c_85w`CA^9G1hWrzOb&RsupuGNZKGZ-KlHawzyj!(6$^?bsxi<p8WwVTREZVH
zZ6Iv$91A5q8Zap!`J5}2Y377!P$+z5cbI8aua!r5BZBSJP&l}PQXn-egiD+eLQR<%
zge{E43<(!q#<F4>h-n~D17Y8k0!hSjx|jw620h^qBZOs?(0N8qKp*g#X$Rv}*b6yy
zCZc=^kS7Rzz(Nl9V4>voI4>Z&#-Rcsgl`qI(BNDxWp5#@jc_{-+npy6vD5T~v(^^^
z$BkmlkO-#PSXoR1d#DE7ZWeo}D!PW)7;8e@;GK+Ob|NH-0N7hwI~CZTr)UcsDxt2H
zOhmO{$@Izz1X0M*y}HQgR)L$uraW#K9mr#zwEFm4D$%Dt`1}nO+6}$|%YO`-z;F4~
z5fzx{74Y)$ga|BPl#qP}QyYM@>LwvKyVqTT<m@>o^Rcnk4~R^?d6E!Yx};RfRC>s;
z;#e8$XIIq=+EKMNdVz}L8f*96x6eD<9Y;m05BdSh5ti}q9r-G)e($?-8Dz1_s^YjJ
zC|P&9>_hq9decO?(;K|#X=w+SGTicqFy53KCvq%KYrj)ZG}4oAxQ52@JBRSzAp~5<
zoiau~NMAo~f(%^Cm#&bq>!(hTfu>~0V7g9^t1_f<lfZi@uAh311@8n-UoCv2>^hEP
zfYb2CXlbs?DC79@WnAC*F?8(|jV4~8crCxBS@8H(1$gbZytSF>6f;eM<H~_I7I;&y
zVk&V)nG+9b;De5Og}932s>*RKmHI|Y9h`LKQ)H5|V&M}6@Ja>H0^iV!k^ynIvg=sZ
zI6h&tbXl3``Z|^YJ0nVl3}Sg$4;(LDR!XDC9!pnT^D9mh4K5x?mtB3S@Vl~f6&-iN
zF-Ce&(LkCo=`yK%`BI&isoI;ag%>?;@WN>r3D;bAxzGVEgimIDDp&Od0~M!cY6hp4
z8&}+KAFE-ZU~SiEADL?-9!qpt4aC~L%QlT~#&F{cH$?N8=y2=a+3;Onc8qLc2Ep(^
zi%(#uv`+JhXYQlxuDY3zedbqp^Xm=dxzhvBBb$dhKJT25tj1ue1tX#|%p%F*@<0#+
zH;#|mwgxAtHhA$j>huahj@VWxkMKDXQ;j3CRjzrJl?`$fcktmd4*M5^9*rFw->gxO
z8H--qdF=vB3COBwaBVo<GCo0HH^FIcOY36DW`6NqV^gbb&=07?k^y=t$vAdf)AVou
zXg?wwpm=W#Xtv^Pd%f|v7sWzM12GNkP8x9DY<DNw_IO!*%~#m9gki^TpJ>+yWHBN@
z#sk?S+pO3CFd{~oJ%>|WWW9vJU`HalqH%$ofx){Z5SDXb81Mz}t-_mPVMyS`llWjD
z$1(G5{8F@Lenk`vh<F%HYz*KEqd>Dc+&OWr4^?^<1mv5LF+(CiIkAkG26i0{m_OxR
zhvyil9n^q*B=$$l4M#i?jviz@?OMpX;c~G@wuxu}7!k9~7US|=#F%hs%VsQSWrhhB
zFd#z<S_no(!C0=`PI3ShUe3kY?QB%QLcojA#Gv38;<d2>2&19}Yb@}xL>M6W@LyoP
zOvTB9UY+20lqrr(2~|#zmv)&Tu~<w4F%9f&4TSh@?`-yB^>?ZUyjouk5nkmcQ-E|r
zxeW+{!2?hLd_aatJ7~<nGa>?RPX(o5D+C^bQx+}P{o7Mcckr-s-TCmJtI1=9R}yM$
zfOk27N;e{qE706V3Hb1QM-saO45I>`3VvB83=F)Pl+6o`kSJW$!&KWb1*6g$i1F=}
zuK*a$2@>;2DCNYiF%5J94S4*ty8ve~7IvNntb>c*Lu6p^&yip`aa3oskeBl#WRBk-
zZ6`@!x#hW0v%_&J46lU3g$RgujR0<xQvGq{gvRL|)_?&!k*74A1Gg0haTpu%?5RkE
zw<0M?42xFwRKTccZf#*5K}$+gGC`szQ6D@VeAO$la{%gY0Z@uw%p>8Zp;%r_1D&n`
ze?QhvXCqd@E~5dL9)tV1OSYRx2B;AMloeSG3g+{>4HV!38OSuVg@PiZ6=~lFo)NK@
zTH;)8F($0sS%8eFNi7tlff9uX>O#%#p`)BQ@iEnq$ZH+K4YKGmF@e`fU|mH#@3P=2
z51tA!4GJX#uDlo%6|nBx+Tvxs1w0+VbqnCeY1qU(5^kD`<;64*MGb_18;D}%F;csc
z2Gq^pA`-H~?O=i<!+}A_*vjWNN*GWa@u<(qSpb-kVMK(gJ%udJF^q|D1rw5;_XT#q
zu%U2CIO<~{1I|$tZj$NX+z2e5j3fX{TYxDsBy`TfH}q^ZEKmd1U9?hTbDMZLfQtYl
z1V)9dpFoBSJF)GbP)sbuG!SJCxct_lTtkdpOan>-+}nI~I2#BC72Y<e1`BNYlpPzK
zAJ6$1bW|{7dQL!wg5;}gku<kr27nqFM#P16E|Y(?mC{1rD{48&$p!*Bu_d#E0jmwP
z!PiMh8526sabZ52D|9DWPRmxzBy8<8b>#vUG>dHop4w=mCf=@T4Vq^HIbeW4hEbvN
za3y-|sXx-xYj2jd7%(QpQ^8YTO}woXTT4~wxP}#_*mbwl01lywh0q$n&)oS5jn#D_
z)Im&Lm&4BEY?qZi$bjUjEgobQ8U~i}d{C8JP%uVWK!#DGM}h#j6a{7l<~VC`ONWPL
z|HY0SKblEKGGOa;1T_MD9o@KrD8V=%1_U<svSR=MKmbWZK~#*14h2ScBLVYD`@{MO
z7>+y*!bT9bnc`du*+!}xlUTUf+|t6vNHaAwHnGQ|iKjqdm_Xy2)?<c*k5=kGpf8Q#
z)5QAr@8bh{_W|jQn`%lys_XAHxkoZdnTPtk@Bp6DJC%P2fj_uVG(D;cnvGhVpP&f4
zU}0ypdw%z1>qD+@tpvj>$W3y+(dK0(67V7kyNB#auA<upT8qa)rZu>5+^Hw%c!9qq
z8?GyLXQqbHJuy=TEN7`R?WCWRnBj?+o0KW8cPEYP#B|ExPv{UR--+Xnv!Dg}g<Fa;
zGSjJhZno?F%t9=@s7@b)Jl?5cX{PY#=+HtAL=XuQ#He7nq{JjjPfelJlw?Z6VPzaN
zg9An<ram;Iq6G^$+xhScId`O;!t}!g;bb>1I%w1{X!ME4(0emJq_wNp?Z%QuN3<R%
z^rE4^A3;^KH_@W$KMT=brxwznX(g19nMCb82e<L{b+qD-OQr0vua2d-B+aI6+1f;_
zo+zdAH`j;6D?GO^^}l)$C1&xU!CRe5?_W$CU(@h{(ex{2h~J)HGJ6c%@%wkDJ1*)^
zUo5DhUq8P}<UZ-(T$;pfpP8D#F4lH>XHF$O_J-C*?{ObVO*Wrp)>bsqFYj9t67TfG
z^XT%i1=KAq0nJX2a$kDut4hI}b^ktm1JqisW?KtAJ97ig_<D<!b>`R3mpzVV-8aIN
zy`E*Cv5{tcW6JK`pD~O(hH@kw2(~Os;(%_0=#If>(fgG@(bH?*7d0P}J%q06Glue#
zv#6o9iC*9IHT}E%3)(kxAl+Sjen3<FY0bOzVbweum0dzt_8x8Ey;1QU{b$o0fj_eQ
zFuJ(c5!8cew(<b>=$e`IMYVPh`N!UqDK&xb102d5x6+FnX49M+lsSYDh+tn1cuDe?
zMLn6_GU?Vkrc*|SX0+7S)Y6-8%%tzW`7s#bu*%?x=&(1!QX^~$OmhSc3<Pm8-G$vB
z@J=A4uu;*{!Y5hsS_yMXM2cWqh%pf}Bs6`*zFjmh<4x_R;8Nt7m5`o5C3g;!f!zS&
z-Z|)oAyo6zR$6?+&s2DRKN@&lF|B)PH8pN*pwd4sVWXpharhkjyY`~NHw~dpGd55=
z4?LcD<qb4wY6(@$Di?#K=(eF$bn`IU{9ZY=Zfo_X+2a0d!Vf4GGz~=3?&&G<bmKXF
zWnfo&#Lerv(+cV5mGyMT3#;htqk7PUafS5HPbz2=8;l6AepW$mf2|n-+Z(hw*I;;?
ztDD#`=}n*fxRoAfgJk+SeQ3&=edwbfw$L`lfBcPgV#vV2xaIu5H2L&C^xk({`6lSz
z?uu7+-8E(3s>{A!lbwaR<vhsVo8J50MRsl%ZOG81Rtqg>zV(4pgTE`QG$lTXrt}}D
zAD675f%esXPoy7fSJG2#ARL>s4^8TS63t>mW6`#?bk)LV^zl88e!)h_ReevO?`lhh
zrwM&dpr2}2(bH?+r(<$P(8PWxvVrk4ZEdNiYuLbef6F{JNaoN*1&7m=e&gtSuA_lZ
zcKj2=&#NnA2HNP-!eePt-?8+~qGhtO!4$^(SN{IYkA2%5*b%XK;S&1rgHLH&-8TBw
zmA|BOFF1pK`0giL|2OLmKbDxtTEq__3IS9=t6h7Kc_2mor=j2!fT|sy2^bb~;1zo!
zU{s*bSbtHSVo0R0Yvi&Czog+KhVmZRL{at=5C56UR;{6-{8F#WuDY1Avb#}ZLnFQU
z`b_%d!_VpB%g(0}`|L$&>8Z56zJa!H-%h!CIrNXey-FL_ZKNqTT|;ZvtfwA5@&tFq
z@>TTMgU_%~EuJ)c=J%l6?wUrcSFNQ-9(al_yyP4@=#c&C`9HrbFR%IiLwC}as;#{3
zHc9IGcFtUS;V=IXJ)U#H>2%ETM^H1LJ&OAG#PCi8hD7o0dr{q@T1xF}x)|emkV!~S
zq-uUTYHMtxs?RoyA(1vXT?~ox*R>~9=(u9mCdxUy2POAPrRK^;Pdwnli&6H>3Tmls
zp;eEUQjakO)Z_SkDt~JOdC_cKw_U96J+VFg${fjHdIK8~OIWvk^0cQy)Rn^Rlb(`5
zKP<1~#aZn#$ia{pRFG^K5|y>hw2nOyd~Y&BFg)PG<M7=38>z0Lm7aNL10B0>cRFfh
zcY61mDtdcPl|kpzAFFB9uq?{YPNEG}n&Dy;dPH_D**EI4XS3{ETx9R&Pj>xLb;euo
z^MGS|h-9QtqlvCB3?A03iwlpG0lZ&o4}m~=63@3|`eA<EYHH?1kn`$RNm;Ly?zET<
ziSnkck_Mpzx{am<b!%vA^EOI~PqgE0TP<(}$=wMbcpToYm`mH+;Nkd&#^vo#BQyKc
zH#Md7W%UyMX}O)#%jvk>eF)PkRV~}Jx@=tQS(eLtGe5GVf=6rE1M$)euNXkH-v5Lq
z@JqD%^zBV+)@(5HBaOgN!C_NYJx5AQ@R$~8@)1?;WGodiSU^A?xWV*sJR6QMDqu`B
z!$YC>olY?%U_^}EZ*MtWYYk5Y<oD`H1%<t6^X5vr{)VfWnRu$+T0`00v*_Fl&!F{d
zH&9MawipN%4AY}$o>)+Dt&Hb+yT3j63Z<r|QgO*(HZU4QP`thD7YFT2^XDz{q*+^A
zCwMSO5W08ImULQLnjGE%nuWa!sJgmF$`3j0Kzi$qciDJorsKvOC3!GZ1`h5o@jdMe
zi!H-3CbIU;ro7{O()Xu+Nh4o4$WT`sKPgszR8IY_97M_asg!$k4{F-fKwG~uZ~DDX
z>rL4Q<xt+SJ*jR%HDSO<@WRU++D*!nvXZEAeFG)&V1bZQm?~F%IcYY<j0i(F!6H~E
z5YB))VqiKQJu;gvxOXu<HM!Uz-O$uVv*%UQ|BcC~9^5`hjL4$R)y?$Hk~#zCs_}({
zPwn<r`rXTA^!4I83WitGJ56x2(h_MSHB&Yls0al)=DL9Khvd-yMcwGAeX?lLntI<x
z1nBHKvbV78n(H}G_RJ8nV`Siuj4Sx!5C22<nQza68q9!Vm%#-9gVOTpguIb7Vey~o
zp26oDIL&P>G-LC3^vlAd#V{Df(;Q{nH?a|6pBBzcNTUO@i|C=Uw*(h>Gb_HQiwcio
zylyhhv3mPvT3o-L`ljRxOh$YPRZ$&fBxt|$9*Nq006dQBHiU*{^rq1{Bk4OfE~=Vq
znRkm}WN_$+Fz(oK$5S}Qgq6a`{YJ=Gw|-r@H9Mj>R4rRR-A43?C~D2;hg>Ka@CMHY
z4!#0a-VDOV34gIM;X}*eb3bC_UV`+8dmf?R-}MmPaNX@R|K~+?=-~&65wWtgjBc5B
z7rpz=hXRM!qN?!RpZ_k=FFv0`RqQQDOV@53$i(W=8?O5`z52?V0yARda9=b9*y9T{
zZ=H5GyQ(msM&d=;n>`~4FjBz##tj|sAVP2#`wC~_8LZWz4~(D<|5{6p<&6Q7R(`UX
z5_q1x@a#U6%7ek?ckN!DoFnom_ozII=O@^T4>uY3UU+qjYpJ!qnTl^8M!CoIq>_7v
z3r?bLP#}?Op;>96X%LS^Ts06*yJH^ro=XPO>;L2F3N{j);j^Esc^yOoopx9r5BAA4
zYpywG|M!nJ(d4H}>EYMb$!m#ky}&fsz3`T@F<8$A%8k4}28PM47xt4Xvoo|o6$yAD
z4&$<9_K3{>soKd>&~(?9y}?6v^La3s?63&}g8oE_d~>m70F*5Qbnt{beZYA7*Tyet
zYg4_g9ErI#D=0f5ozBibl#0^}>0_RrK(O*~JWqMx#Zz<Go1nt?wHn@8`G-(ZdI5dB
zWuX+UX{@Abp5C~$;Aq+>qaUxMI8O326U_&Q{kjdHW4aHgjKmZRO$>hs)|#~(>$iQe
zrL`n@91pjn4n2te``SCQh9Ee!pHl6;8eYbm9|~?TXfHp(ACzWLz<Y%qA9zD+)D4Mr
zUVs9R1D@p7!bHR|mjq7(!iv&Wa$UBhRIYhFG>-uiO}xDX0aFUCjF-S?jH^&p$*ysp
z{9L)BOtJ<H?CXoB!gsrFtE(6HOm#I|uN;z-lW7P~zaXf3%2uwCbnMGp1HCWmN69%U
zRLf7G@Hix-#mg>?Zu?|Y0^j6^{B8uTeQ_0idFUrJ|C+hfhX<eBBQ<v@s4l+oXPR@=
zXSC|EWi)Vd38f844~e(<rui_2X|D(PhE&%=Z4E8d%x-f081MnjubE~U(;T4FL|w5E
zJq?`4ZQVUHkrtHI)8Tt($>Pag>>b#f+b<(EUKU^e^OH?9=H{Pi+Owr};j#I2=<qCI
z0EWa*E4Il($@~AchPr1Y(vUuBA@P3mLYcHX448WMcEN*DQOzsJ^>D|FWi;-#`7-Ts
z^~r_QuctZPqF|zN-MO+4u*hy2aGLB3Ldb3o7c$cwe2jG+gOAPGn+lV2sI-0)?ZeXx
z@D$`HWz)dao|MY&?>mal<pqzQ(0M=egXGc|=vRG?r@b@#irQ6mC-*pzKHWNBraw@L
z;0-#5{<iT`x?uhzbkp*`)1|$Srs3&*1n<7GH)Wpx&Ov8UeOn{dwrrQR6Ixrw(KG8l
zpi37$Nl)-1%xii5M1GRi&s4c~jox>!f_$2I{gw374?ojqpMIg;bUHvDt-?bmf1)_8
z0e+Y;JPBs2yE7?kGC~1aQ2{Ho`4miRel+6S>ou1&)<)#yb~i{uIn`UWr-Q=Yy(GVH
zzut1K(Fbt@*dv0e5Clw<Ae3+16qF_m7=)x`&F!hCI3!d5Qgb}kyftNOC0W271p!kt
zdtwO3y`9)Ck=l4SM#<g7Wyc0~XJnLgqd`-ODf<A;P~7~!=4q(@b_*}0Y@_a@G<T&{
zx0~M4JQX=d^azTFK3vW7;qxy3mcBgrV_I_Se2Py^r26G*PSm7orD^8IVqO{ur`=&J
zwD7?+xA6kn-~6(_?9Lcmm`2x}Qb_w1Wl9wv{h-Z>&t0~SpFrE`;GtT+wf;Ju+Cb=+
zpAr)9+oiQM;n8Ju+>P_-?!T3Z@v?#!?K;DI-)Y{DQF~bj6epBD-SuU!W7&BP02|47
z|7~>;*)^TRLtzbS5I06Wi$_8&wlra^nD%%&8xC0Hc;moR=$3(}@h*#QvR>hWf+NHO
z0qAe4mx~dytbPMEG3*HTBq*z-IIVzsrex836+ak+i_;1v4m|L%tbQZowb0%fY=Cga
z5~lOJRd3Ka^B-lS;X~?{m`3Xws|<V<!5RsKy)!j$mC6rxmBp69032o6JWW3BrfYfK
z-)ef{uP-}F!x@b&s65zPADk^E9g2b*|2shZ@eU{j31^4t6YCJGCNc(Qtc&Q!XD;0F
z+neZn-V#$(GLYV%@iEQ)ZXTU>)_9&i7)BE(UqO5AJwy<{{rU$wfY&>O3Ro10#gqBH
zv;ls>&x>i%f~B4`H*czx>5%N~EV}0U%Xu-3)=@*%Gw;U*vUcNugZHCuS(!AbXh0~G
zJ-)o`$rXf;3J1M=1l299mhGRIuE28UewPoR<-c1@`MlsRjy+AA-z}%iVcjU}fbO!}
zB7wK_4VqpeB(P4RZV}I=>v*M%*Hg!<U_68z-Ue8=u$JO@G3W5d_m!!Rs?RGZgK1{F
z(5z*eu@GGi{Ds>B9~EA`b1z!5X1i?v#G*-VKDu~xK0WxKwKVz{IkGo?7Vjh&&<h4b
z2JgP8rb1qzIrS`U$H$MQbyT+<uSIspLp_IZ`z~3#ostvd>HaI(E5RO#uNKybH)Frz
z4Ek^`Pl<A$xR%%5AS`BnIwM41_H7Q?*V%Li8BE#ZEV9?K?5VV0ab}pZvyv@_gr*~H
zc;FIappbk=##_9W0UtG(JU;YN-jT76p5omTNt}x*i&J_YK!02RDIJtmLdoo<m{Yw>
ztAee9@myBfRKv!CzBrKyEv;WCcqen&OB-f0-cZI%q_1_u0G^4}JjH><oKxB3fT@m!
zTxY+OJT_i>(YH(=@aN|rF7=f0`U=ILUU5_|sl1usrrV~l$GlahG<x^Z#+Ay7t<<P{
z)HUrXrQsSnfY(HJNpuF!peY^)Zf`Gc1ST|_8U#EXuppRPrx+5b<=H2mrztm2<Q*2d
zbi~o4WH85q#!cm$>EHi&gU&wxG}>ohZB83T#225<2{a@iutQ=jw8Y9-Or6x$)Ddv&
zx7B;n1TS;G_?8Yk@(@}4iRqP$%nTOYK^TB~fFV>_QAMT8S5i^&AR0D&2w_SE-V7%{
z3TJn{V!k+>#g;ZbSd`V)*vh*rN~!Oq18LOkW5gR#F>52$^87g#SPtT8he1;{qq3!@
ziPk>9l4^N?L0HXreHiZ$2Oi4$UN(@r@rr$fR^B(i;A(!l;iiRm1k)n}J!lF-?8{RF
zX!mfQ%&mkh%`Rv5Klk27y70K3G=rzM;Eni%w*X@rWMB4HOg*!&e1MO#hhAMnl{K0d
z(F+f-Fib`a%s`atxo=H<x>SCfnd$L#^~t?y;whQ|fd!l|f4qsep9XrV1li?l=gGd-
zMfSZdI@64yi%0i#$i70CJ%ME}WZAVrO_P1IA-ml3mArbw+EysS8i|>2f2g43E{UPS
z2)J$9GUVqbS=M`M6CYIc?Aj0L{K6yHU^q~`5m<b=szLKeCi4l3M|IzuUMc_FAdSkJ
zsD=K_(-Y^hS7UsS1H>CKlRXw?4ZJm+!zrA1NOrNrtD5WRH!J?bXxfy>MBX-<z*{~M
zHnV~9{Q8e+1=ol9`v9f|%Kn8l5`Gt37WOVQ&XAaT<Fy8%mtOdnJS-a-hO(eE?=c7P
zn0SyWji}EN=-e<1pdWM_w4-fxOdl8KzPR5$!6jrePe1oCU31wq9|Y|nc$&}3>c$2{
zh3te-rSbeUifIE3*ro-iN&~MYLyKtI&68yN=!3t1g0QBdeB)*tU@)5Cp|P>iS6x=3
zd3m|CjSZEChCsKe6>fKpN80Ye^pV;(jT*2c!_w=pP*ZkWaGu(&;iTb)2bk3U>2knT
z;|6;hDVn%hdeL;&5ld?tc#41T6C?P&2h(34KDl&#Ws}VqPv*Vy@J667tf|1UyOvI&
z6LZ5uQQsaZ@(zLWE#~?F<l|;pn9HwGZlkbvYXBD^I<njE$Zj%pO!j0s+$&t!4P!#y
zvB7VJ#HoaG)UhV}lYf1PuD$XmC{fGcZ@VOVwo9hU!U09?yya7cp1k{_k_UY;G!&33
zl;P7zXb~MIkJmSB;WZFW4tmOARIQe6of;Yz6L#laAm~h$*sZ|<gR?I~g6n+bPxtaW
zC4Mb<ZeN;Af&J5jRdpdJKu{CR76U!N@~#KwKZ!kTN&Lo6GX$&8gz^&urDmRb#(OvL
zBXpyT`r+k+i$O{7+dtk#ciebaKoz*JHnB$r)0&u$NeqC9Vg|eh_&7rw3$s4Lvl+1N
z!D&Q*elVKY_Zvy5tPGrgi-gXuiWBKmX)t*k*d>jiI;tf2u%JdgU(zmL3eQ>8u)5xv
zC21UH<%Q#l5X&?)&>8K%jtvE8z}XUIE<1dzaBg@g$0?X@0mg_IjvKr)FSP8op6f(+
zO}p{aG1&ukiHbwXj={smy~8D;)<{@|2*9xx`iNKPgSvpa5Oc{AP#6Qs2(a=DZ-ZS3
zjfpmvMKd5k(HXpIG2y~pBVl4j9y5n)7$I)!BOtk(JYKmbFIJtYT-b+kY~y)qgLQ~q
zj51}x{J@|H7PP4i4XjfQiC|2GQwGn)m;d{Q50+XJ4q6PhgBpl<TEnH@;9b%MA(pk%
zG!S|)-D#|Ka>a2xrSk#Tv77c*V+7$-4q-$%3<+s>cq<%QHqcalK!$a2vSSB;24q-q
zxdNARRjqOLfI-bDvIY&*&XZAY$@V*~Vc>Q!VyRjv$sq5{loDqqdlOhFyz@e9LP%&z
zjlo?$+=_VpxWdL&4g5mZ<tvVvfJYAx<!#hzz_-IwXrU#jOwgpw(=smfx?C34D7?gn
zQqBJOi!R68?#vLTHX;quaT!@%Bc&6=+wmHJdw=%}swW1!Vrt`|-A{CzM37$va{xjP
zrZ!|yvS%w``_%=;B};Gu@{J5FV&y0h!2k|fzd5woLH(pKwXq|D>V4L_@ZgWBjQ~9`
z5GEmDG_>$3l6dRpcAlcIZ*0)s!r9bBO`O-n2PmpfBj+_RjKJ}fJgz7MeyAY4F(2_f
zy^_F-R#m_|HrnJk2EMY#LhW=E!vxIpzX`3dV%L}kBG7=_k01gvF_f4FI-mi!UWkFn
zEx!ZR>_VvCl6wr$N;Zeu97zqzHB%9=U)@0!cenx~+CkBGuRWaFLUE{Sa?<q5x58mS
zh9|(<Pcc|40|J9Lrf%SZ5G~nMWlLDd0-hH!Gi~5wngYfO@3FAeV<1=<l_>KQ->$9K
zKw5iG2iM;UPlsfPM+EpNj~NosL@Y$C0Zadjm_`gSrh&*bAh$S14b}^Tl|@$TZh;kK
z{P9+&A6@E%G4S!g<rx6R#p*d+vEzoJgL;zcS_P&AW-K^|Fd{I>W8{ad82DRxdI4Sp
z7!#7|Ng`M+OwBMp+Ig~q1Mgx{I=7Pyq@$)n;&3Fk@<i~9zho_KJYSi-Ml1Fjal0;K
zsgN27>~0}ZVgNA>bU*{4dR(aT4phBcqhgR@0fVV8R5|qHgh5(}a>QXwI6(nvz-kHm
zw*|oxHDLlWg9&4zMHT~XROm1G=7a$g;EmvasH>HC(KPWiLTCfR4<Bw^1d+iFoU4JM
z)6ND6cCN@KA2uS)zy<}|Ix&xgsgYRBLjxZD%L6)=9n(M<8jyRE-os)YEeyr^168+t
zyJ|TXqZR@#_Cm>a`@-|G`_rrgT2(69_6qDN2EdcJ;)Rn&xfmgKx<;8b+nNbEkoFs_
zxPEbb!1+|CP=ffH3fifecO>EymJB}lv4cQp{)h)ei)!r;4+C1*y*p@pVyc6uS+Ipv
ze<iud%6KtDf>jd>rUslp0%zKUjKyLa@T&p67vV0Yg6df6s`6vkPSyY`+}aMPEnxJp
zGzyogF~^fJ8@>hCmA17yz^advDbL!16gcYEAvN}FOa`IR(W3C`k#!3^5W|3w1(D&Z
z!6~wDd>v8Yg9ms**yWJKueV6BoF!t_2o8h9ln0CnyqH`9(})=oRxRzJan+ahQ1N48
zM@<7RJ;{1sbt#To)iFZagJmc^NE@J093zgAG$IBi9%I5ZCalH+s`5j?s4md1F^hth
zX<!f#1Dvz7Inx%RQH%QY*x2f84}U5nm?*)@jC#?=_}GErk7&WxPhJlJV<IuZ-8_)R
zp?nCHP{6zfhlJehUUx|>$k)kyWUlpt>ZkHalejMBH+Z5<rSaxW6_1s5eZAlftT+}J
zZH9m=()b{#xJoNHC!T6|;Ka&IeeNoH@!#$%xKE7beln3;I!@k{tK!QRb6+|gvb&TS
z{jBSifnU|n(SKE3>+^AjJZ8V%F)}RI@2z;<0HzesmsA|Q;J&NU&NA@sTDFwikB`Eh
za?>?J6EI3%k)6xNoibWJXy3^<Tq*6mYzgp2)AiG@lqb@Xp@WV1GNuWf>!+cN2qzIw
znGPNCy<ll6mz_wHk><jZp~Xgg`O=kKb^_yF#WgYBkRpzQFQVm)cM_LfH+6zuHkji~
zA7#r{(%A9G)3uyNz^lBkox*W06uj|c81`zdY=~J_s^d+Xa)ro%>)3I}%Ll+Jjw|#%
ziQfl>t5M&S2_i!=^Lg!*t0caB*$U=m45u|d!ONt{mrLEK4@YmSbaBZbBd*Hu4k(1;
zk|LVKG%-jknktR@RDAhzu5a8JrUTe`(b=TQ6J(vm$`z~^E}MA$Rg#825r@~K6nyG<
zP*gGNWfJOUooT!r&orUmIDQY-1R6c|I6CfxV}!SlXMGAVThJC_>gSPgNv9r>ZL2w!
z=n@)mc8Fk1Md!HSU^T?bx}pXG+nsw29zWbdI33Cjzl-JJ9EpjSP2Xu;b-Fs?vWABM
zA4hnSWuJ8U4ZN@)PojaGz(@!k@Lb!<<h64PY$y%_IJr_zujHp%ZBKzb<4P5RC*{~{
zXrp45Tba>8tVdb%UI<17z7{l)Kw2Ol>WFOo0F+FMp7n|W7<I|jg<mVI83#@6-7;pL
zOH5~3s{`LG883i@I#CoC53hi=J*{!GxzXg<2@0%s!g>dtFtQB!bX;7x_>n)|Pq$6K
zlj{q7nHWH@y994?cK2O?ZY=Eb8nAYgU0#@&0G+P^xrgYzrro3Wcw~1zbGvp8T}EyC
zI1!09F%UUy0S_{!w5ZNV1rX3na54DOFl=}pwb-%^1RF6Mh=mg~-(b$na*JtT7=R5%
z-M~1{CqbbUik2b=qXEW4f^l$F94~f^<MXcF`LXjL28W)NkO1Qa1^~{fu*2B|vJ~M!
zE4+Cd>n1GO0xq5jHfmyqgiU+9e!|(%yS_v*38Jn6xqn5_QzAf#I`3VO;BKdufC1lB
zdXOR$C}6m;6zNgzxmx8rHHZ%C%u}$zub}HaJiE|!$#Sc~>B@J52|v%9Q=!Ew!1P6e
z7!bN=MK>U@4kQG&2RoW4Bc8W#THe>@0jp)>mGEtRVrB}A2|iOowG6JZHIzL+F+(D#
z3U`e{)v&t;w=phvoCfrs5!oFl(tG)i6K@CAw0r%&xHG^S@C?DqJdrE~&=%_8i>3P+
zI<#3LDwnUST9qXf?Q|@aSjk(ngT^f^1%-1fREC7XryEe%c}nO&M0xK8PwikzL4~+D
zyim)_3!$L=UA1Wu_%mz@_e93l&_?!5Bs0s2e1x{bk}DI784{kV>$(N15xXvjG0t|5
z1}r_p`yS=Zng!jsQ+Pw~7A01Zl|XKJs;o<2oo((WNKhj}lMZCuP?hX9TR>&nt~$1b
zkR_@aG8oCM0ZAwS)^a~_13wzX0xQJRH>LyByC&=qsN7({UgVW>wuPt!QyBd6ELk4{
z|B4o(X+(e`=%NV}3rOQ&EF8s+cXYW0$lcu1EJca%Oz6zv8Z#u^G}cA)^mgl_+{M`1
zDH<?-^kMdnFu`|<Y*DIow-(iCe-~w;EE3@{x<rC!V*vz$G3Ts6hqv-<joWBz3HM?r
zT^B@WRxma#u<=+-$zB0>LqY+%bEQhntD{n88;e85h%ny3s_6vlA>f#Zi{s&%v)ZvZ
zRXz?HCh^cQnId6)wN8TRa<%dnPhLAI(;jZrVQ7dk!SIRT6D)Fw84{Wvy5zUsMqQG(
z7*jh~18%=+VIkH_oGr0iXvDL<oziwjI*OHpl-?kgsLr&tr4Yx*TDLW>qjd11IrFXc
z`Xea3^Amdl54_sW2NN$6YPLm^JQ`!_1aI8b-npSDVnL-oz{e-Cda%=iFKk4#wKcIZ
z;bX^#$!0(d>m*<_SOfUrnG1f|7ngawFcfxX3m>2rm&iQxc@p3@w*Awp#V!z6U8oDN
z5@TU!Xu$WqGt8b6Ciu<}J)AmsNpXC)Z8(|;0UL>;usYxJ8fmv0Fu-{Q43aX)@qlLp
z3p}FQ)=xZPBL#RKwFF*Q66edGJcV134T5IGS<23NF2u=;c#JpK7$^*L!a(Kl)k(xs
zgeV61<RrXrqK)vXZfjE-sKT>zTcv}LB%vYZ5%MxJrZKcdj1FFTFvoO5JhtPCo-DK&
zx3#6-#)qZUUzCla<`$NTq2cvNOu!lpQ!=o3|D*TO)N5}x=s{NO;DA>KpQJ?W<`7LA
zFtNx^(f}GqeRdKHuGQk8npoHY8o+N?eS%h}dI_!}f)&&UxRqL0X?Ldx*0h!1XvQO!
zUA14ZYcv_{1X_mdc;pNbe1L?YVDFTHgF6OWJs1&{5&bI;p$Zw8WjVjWx&YFO<cCi~
zYzF2yybuX&D7eXwx?GJ2Rj1RqQ2BnZY&6I=QV)1#gJDWX1&D}~FLCN+G8+*%QX752
zgiw%CzV;u`m&S}emiqSZ6J^T&$>rpBr>CELn11)b?f#KE84~?TeLA_Sh{+o_mM|zJ
zW+zc{uaqz_Owg3xsqDQoeraYwh*)w#s;0~ka9yStzeejPfHBoGoYw$AGb1Rds>}or
z78`%s3Bih8%d*lFD4*NjE97@i3V5heEEnc#Pc<s7uAt?Hr|KwRJlt&ELa;J7c$GKK
zOLnC~mup_PMB!7>a9(q{-0PkntjtMAr9<gj!O0EANQ91f${qwYJ29Pd5;I&Nw07y1
zkgg4q(3>7qv|B=&WdL=wqW~#Lg-MhdpGw`i&fr0#6^N~{0!wfLWw4;w(WW5GVKXl;
z*U|?A>Dp*oL_{=!rz>zagqCe7<TCUZ*|Fi(arg!je65D9X3s>t#RK651aArWR6(|b
zvM~|Izr930N*kfm*GL>R>K8Qn#AE2a86VQx)$0^5JM^k;-C<#Mp{<o)a>a$zkBywi
zA9|K*s%xx8of5Zqmrki-rw~obNv8e(a|k7NPnP<ds~Tz5W6NptjE#~`8<0)|r<G97
zp?OrdsD|cU@}0qF!MS~@|J8#iF^h3|$#CiYi>dsz^+q`&Jx=IFLw-Mks%CGZ#nXS5
zviwsEX%N#)$YfVra~o}ZeI2d*<5DRLR-XXu$gdFh7dtCq^pF71U=;-b+pCQ*)jczj
z{&r&tWo2l$k}Y*D^z_>s=!5UK3dL~;=g>rMr_9s@YUV?5-kDQHkH4X{?dgZ-(Pd+M
zQMa@NSt<S)x8GY|RSDin5#j}-8J38_RB0jf!2=^GNjH9Lwzbf++}~$@y+t5~^hu>h
zt}UYU<am+q!GEu%cfSc;)-OMqb=I2>9@dSPtgWYskCqBO==#N*?7DvDEmPO;{$X!Q
z<+@Z@ThT}t->3Z^RGzOZ9x?Ip9K<v#{~CE6r6y><_wvSSdVbw(`l@=F6!uT;LHCxN
zPu-I;cpkou?pygf&8gOS>BnV%D7lET^|A+6zfE6nT`qX}$ysz>!I5-q&Ip=YyMpdr
z^`;E8nF*=%VDUxND<xat);DgU7dFhMZ);YFP5!sx*HE{_G>tL-Ub1Z+-BS8bBW;af
z%VYSz2CYM2EJ@-;1fvc=m`>uOvC}is<q7@OfBl!f`rp^Wiz{twCew(Q^$_ZSCrcqm
zQHQp;(rimB|7e?zu8&ak+}25`GIa$En?0g6%>#jVa<qz}qh5jT!Kos#dtA3}*-F2?
z;{kf`_m2k%RKjPD_vu?msi~1YMF$Xc$v`(zAD7}Tn>FLj_kHt*bwFFcuA(2$n?v7?
z{hS)sY^S1IhZ-J+kuM!c=|vgTQrB$c32|1;ps6La<$sm*&9Sqo;-hjZx_KBSWSACk
z0zd5*-#JW-41*!y-7th|f3BuEhkrt=pIJeL=k+7;PB4&XeFlL}ir_cr{J2)7dW7@p
z3T$Rt!Hry1p^;&UC<IGZi0F(rKL`O~7V}yw`etbzUH0HII{ThQw2lX_X=nA(=1sZk
zYfmerg{$i6#9QXm3-6cH8EiZ#F9QsWuNKzODYq}A+4Hv2<TLwFMk-duM~>%3)8yC^
zQ);tZXF_(QeTFC4C_3w|MRdk*7SY1h+iCI{z1dX_ofF-A#Xzdq+C*pHy@*z9XrLR|
zV1|65%AVoh!{EYH+Sbs@E8{g<z=5v6g|7d|x@MZt_0+Tb@D1IBdG)gjx|EG+e5OCW
zQtI;iC9)g9p_TA>*$4E?c~8+rKR-!7*R7%J`kyFk2{26GJm^$f+fYRp{q!jPRJV$5
z8FVJ4V!<GXn+KgiYuOOEWd1WWkMVBme~NC9#L<I8E~Vo10;+1Rr38yh9YgNdwWV~;
zlIQ5sh0oBMhDy4wuU4O8`Q;7&qiYubRX+EXy{WQ&UEiPiad0?R2PRt}8xDv%?acAC
zaKU1_?Z&%k-jDO??DJ07#}Mc(xbD!uWe14VsJ9(oB%dt^b^vgj@)t5(0@jnXwRLQv
zr9n2t^akK?#FxgK=9z#F+OS50jR{TCPC7^8oC{8;V~#&UUQ4=Ro%Tek7#}u#2wi&R
zg_ND0#pTWPzu9x>-~V`n1`O;cFOpfiW<B-jkw;nC-Dt(~RrJ_{&&UeVq5Q&{%dWau
z@*5i(>CM+?(kCB&E@b!Je*~R=_Q{mrtB0i5u;=5xdmfSa&9_gXg5LQO->|Nn9=P{0
zi64K$(R4DuU???}-QpZ>yK6dId2P%KEX!{suOnaXU7#ZrcRX%5hD1|E6D|Gq0)xr5
z&zI3&kM2tuL%UHO4;J$${6O0l*V4!r540H)-4D&BxTJV71X^lasO<4l>M^E(@{Z4^
zP5iWlP;~oV?8T_1)V`)mGd_iXaOsIu%};o3jcru**=8DWT`{E(PN$}g4W9KG40bdU
z{9fUp9);duknmHn0qo$zU(#>8qn4_g7P|N4H3s3AKiW)xxO^a$@Y8r%c_XE#B+%UD
zb=1_-PG2mjp)1D~(7=Ke`QS<Zc{VQUc))!2osD$tzTN4lk=gXgkJS<3Ro3uPzE+xV
z>ooVtHar0aqaKkN|MhP?gT&jq2L<s@neS11b(1L`Y?JGel|*;{cLP<kr=nL5yRlhe
z$N!=`ea(H@tL&{Wt7z(<N@?l326}2rk<E~(WL^L6?-pHu$hu}@1-f3shC4zP|At^-
zw0Nwz7a)%>Tf2)#!UIsx{@>Om62l<#&DK&Hoi{?JIpA{dpVpJ^So#XpwKPz_lsq1M
z<LRKRVp_n4!vHS(&GP?9S>Kc#DLXK05PiO7A^m#!KiEj9pxXzZ!_UB)(S=HCTDH^k
z>pw+Q!dn${>5%MV>YJQPs~amNubLMhRy5V}n?7*rBd-+n4EPP%e<SbB{Kyj;1@f!Y
zzwqKQc(>tY-(J6+-hN{y?e~k3G;;ra=$kn|1k$lr#Wmv(K`-EoOqpN@1na52t&z)2
z*#%U6u@TYU-pn6A_W^|z{EF#~pvPsi^xAo$+9{i8?^a$L(ZZjEHeM*o9ovK3;1vfe
z?Ut2E$Bj8k+#c8>GH`Hz1H4<eOuBB`1Ti93mX@(q)lSEbK2qS5Q<7y+$J^6VbngJ(
zQ1*+1_7(Th^*3BCMnv`28Yw^b!ZQfQ1;WLboi9ej*I#{4Km9PDa&o#Gb#C0aiK;5M
z3hmsy93vmo808x`i(3krRh3neuC1vxV8V@{Tc}UCxLpxGk~I=aj@)B=$je-|E!Ff1
zBf>2-SLp|w@J$y1Yb+2__=yam+rHUsRP>~!x0^-^^4l8PsFJ-GeXkrugQgFm;g9V{
zO`95MtA1nmst>pk1^jNUA6Fu(^_^E&;1HQy8Rjq5$Ee&5EgJQibgk{~q-;%_7-sCK
zeX{r_!_!miw^Kt?8+#h6>Ho&$i)Z3K9`rU>H`BLE>S!wucnDcMt$~ouUMGYC9&ml(
z@l**^lC9$x@EVM*JkTO!sWJ;qDe&=yx0i++#vPJFzrLs+O*^|cEm~7g8>*V9Z%@s`
zi2?rVQwnK28@rg=>64cdv<!8_i0~7vx>oQL#uw16`}d)@emk6}Mlw~ludB7)H3W3{
z;Nj5h61uGS(KLC$So*fQlq#F+sHZ;tu)1M0on0`B>RKD9p|y$fle6Umits3$+3O(M
z#)GDmC1!DMoaEbUwWky}zvwoQn)s=F9eXxZnAq<G`p?KI^ygt$(D01DD%;o9&tgk(
zg3q>X+k|EYPir8gXKL5nT#PRce({5G2FcS4_yUho0#1v>d<Gi`?L0uc2F`C|Jz{zx
znn9bo07W-uArU+hY?z^#tq3d*l~;^2ugyHhBShVh*n6M7gz)@%i|B^yZl{eK$|a4j
zBaR*=2F8Z<JdgPH2lVMjpG(<cM;>CpU`6N+*ZrDaedSHb8!>V?9eVgdf(PT{mT7m<
zyYGA`Wuti!Cl-RFrKL*wwz_Tf-&fxe7)9{Kzx;!qeDwdRq;dWB>mS5xv876z%YEjF
z=Oqok!wI5WMsRO}a42;>*uWc$KOVCV$e~`R^`TXdE~j>W5)BqG;J4N{Q}OM?DEFA2
zRC3R70f#|>g_lEl4tm4C)>0Ec-8w_%Cz~mO2aN)D@22!lqs{Nyy<blFu+r+Tp{}mT
z*4FQ658#TF(I8j13Z3<-v>R-Ad5RLQSZt}%;ZWI+r>;&qI9Jw4s3+pjdFm-OIe|_+
zERT(ZWSTWsyYXYNtY<?5?*1c2WYH}b_LHjAT8jX@?-`F(v~;bGcOK)h(PG6jXu6d7
zl_Qb`hokn&qQh8*WcIAhX0HT7_e{+&%Hf5UXB^Rk?tGz)Z@O)i%~N*4%KY*vx<16B
zYi_W=f3%4vKed7$d2JngB--iL3pAbjrD>NP9Y1u~FM9wTlRKO;5>x1_t=jsCZV8$Z
zmBou9FDyKY{<!ijs&8%NH4N#LnW#S?@S2D7dmTy-m(8SlJ`(|D>N!2IR-G69Qk2$<
z&dNWSo?16cybpkXdE*y!<Fc3Oq1EqD6F;?M+9OzSN*8LerO?um*00@2O^r=--i2q;
z$o)ppg%_VI#mcZS>cx-95p2IJPRIdNJchv|fxxQ|#4|3&gz`FwanZyEdIOh5*NBix
z`F^8UFG=?=2(N$mf|D)bmBDxo??luMi6Od|VC9N3;iqin8iTL=0&R++uy+B!U;Rpc
zSNri&mX+1bfT^lvS2aJ;DEt8f`%;gdc~ZWjbd_9}Eh&|2UXL7^r}=o+XOhOE&b$9`
zoAI7{$&B)s>Imu@W%9c`xwJv)wD(i{QRT<wwBes-+XoYD$xZWNh|{nK_Mui@tk>4i
zLe1=+?afbl$vG)h$4|AnNB5wFw0KJ49U9%(RgE<iLw+}c*1oukzB=?1T5!!=>T}6J
z$~{t>-U?QqXPM=<;t3-K9cg__C7y<ZqVK#0=PFdGlbSUh3O7{w0N$zd;8la@Gj6Nb
zKG$5$SPyXfMg8d&Huz4sc|J{lb_HE{Y(5=2T>HJ>#e*x_{q9Q!P(6E?;EAYUk3|Mg
zTN!xVH>UIYmkW>cz~d)<!Q*KS1RG69StuDIEr*dX{?-Nb3@<W;_W_F~x7KMl{Ch7S
zKp(R41kVK4J5+CL4O-@h2hlYzPBwInhU9>0rFkp1$%54f*!b?w3t+L}Gu$BL)F2iD
z`RUak(*MnWnjSBEkFIC01QtuyveAHW+u$?lt<B#OJQFGL$yCcz518sexMk33^fpgV
ztY*(dN?ekZ>5sfpZhSfT=*3=*-xr-n?^gauv$vQJeeYMzqtfl=^u^Yt^wio}RKQav
zSnwImfG2YqOPT0D|MqW=w$mk-Uqp?Kjnu?vOH|8Zef+*d1=cYC!-$acBh)C)vciA>
zg|>Eh9vavKp?})6=?p*AL)Gq9u6ZSbQ|FZtf~rB`;3^ms3B2@x*Yda#?MU95vbEwt
zDA0|D{9Zi`a_Z@S&FZ!E*6Z&X`Dh3gvb)2@#V*dmUUDtxsfp^Xnw4MJTg&U)ueX%d
zRBP_?*Z%buee}U>I{c_nvek6>h+#6NvTDU@f%EePg@g+F?==+IZc}cXGxZ@=a(;@e
zfvB5bLrZwz@Ef-BN`8D0uyypn8Ank4@@<sKPn>PM8>9Gc%}Wu_^X(ZWi8OFZF|B*C
zOyDct-z3-SZ@0))O7^H+UN2E0c|pH||7I+x9cgu!N&?6QWLWBsJlYYe_C<H0dFaXB
zqo*bp)1uY&bk|GfZ*E`qP#}EtgXZ;{yKI|GdmO~;X1<(XD^ncbE?F)x*gE<zUQoM|
z7bO~ab6xNjc;kT(rcK;vN+mwN!j;`h^8N3&iXj0H1qOM9RQ6Il{GauNEt~LIU?;`e
z&D#CWt;|Z#E#8x-aGv7+@6@#uwr;y-$n?!m^*vPr*=_v>-Pe}kti?=!U86nRjmYdr
zKh~_00(c)@S~r{0*+T)31$K69YSQ$AvVUy&lFO2{vL=1U90pa#&qlF<t)}-ET|ht7
zuA=|9?h~_eN334f7!dX3>5?^#+I__VB1uITiI9se83s0uhSN^VmzMHpIZs!$^3+BK
z-FeR~1W&sFh0qy9R7Qkdzide89tW&}P;p_llfUF3DhL-W;K4_S0e_g1N#bdaX7-{)
z-H@2~;{w9^g#!-WkFZ{1P|*N`wYlH@L?@j*ns-U`=It{F(&kMSwD&&4Xyf`#^!e<s
z1P-TW-FDYBUh|-NFBbf~m=-NqN~fJQo?swMoO}iCwf7K##q<Qi-G8{17rD%(icOV-
z>5UX#Z_&<Pjh^{EXv|5+%G3wo(lgTN!b{Gf`fc?*1u_F!RLAgnJ#y*FiI>o_r7P&m
z&%Y+C0TQB52#wemuPEoOY5V=-V42ET`N%TL7^2P3V)sUCeJdsLp8sT?A5OqFLGFMV
zC7FZ;n$269D2G?_*Db82IDQfx{`kH!)lv0%g%|{@pIl+6_rQ0LV7O}8{t2T3d+Pe~
z6JP1?7E{l0g*+7!PZjTKQ)vP96`S=L1Op<`0Ng+$ziMrdU!;2S2&gxD8PSr!FGuh?
z{AF4(dj{L-skb&#QK7a4Z+&GWeZOQInuvbMYg``s&pI0Y3oNXQqgg!QA{-*y8@Kbp
zHgR;{l>=p}<16k5$%)!_$zP6k;OSdRz3_t3lnSH#g{S@fxF3JWe5G>Vz4mnN0cSDq
z-YDPFOcm@U!6H-awz&G_0@20CY*cMy?~7L%Sj^$yQchN)cxG_39?a*fU{NckM!a+l
z0|N#a7JL@wCDRn%IRoAQR9Y9A)EG5`gnp@cG$f;d7g?_09Ty37LBU}Hy=wbrs%qIr
ztG8EBBR@sQ@y?603l3!ivW>p0UC!$vnyHLont8y)RK}S+MS-&KYgaOU9A)y^5?O3q
z!1%y1O}*K(P{SS$EMC38_yV4`XrX_Ue<}H>5Q{6jC#6$KS^@n~w~~4!cB4xRjux8B
z8_a2SVJ_4cL=N%;vZ@50_jPO6i$~#N-7B$h{$jm`AcXiH;BG`PDpwHAMU<h$wU;x`
z!DMF(0t+r78G>Aa!Z<J{qHai3R#Z{x@|9FnJczJE15*`P<cLPVITBd=aOSzE&;bYS
zr*XvJ^L|)h#J6v65JLmXuC3vx3pN%o@MCAk+2@}|`|PVdog)8>&*lgoc6gkupTdYa
z8#HLysx>rX<X&{-(T5teVWc39MWD)%z;(i;OT_~MFUTfdfLRuXC&M7V8%D53!mn2X
zTRYVm5+h$Y$k4{p+vZcn2j$d%QZcWa&~CIS-1nb{Q286{sPx{&)c3N1yr{Cf;I!7a
z(1NSkKvX@}pu`c&FS)I;m3MlSQlCo)(jl{t5pP7rtc|iA6u1HPy`tC0Mu!%H{A#Rq
zhK##0YC)1}qE(kkH~JJ!+L$Z%+wOySs!6SDc<TBhgUE0HzJ@SpKKI^6o|foI@7%k$
zcq2afaVsq>s~5Omj_FAw25Mf5dT!5YJim`7Ze%Z1BzPd|Mbls`L_}owxpO0vy$n~K
zTu9gObOu5#djbCO@n-sY<u*zG=7rVt=%m3k<M(?@8fzC|L?8q!yJCDV8pmr*RQT)k
z5;=e4{qMH8>za4XV8_Z--ad;D0v5bJ^y*s9*A~MmTEVW6eWq>8H~O}FPfO#ioY(T=
z#)JWEC2`o?SVPaP`;=B}*F1y|t(r;q4>_M++y4eBe_+LbX*(Mcp!OiInfT+-i|Jqc
zUMFP_t(rj%Y;+);o_`RX(`%H(@%7YRSI~dT=g^mYK7~3%;;|wBXO#bT#T!)JT2Ipl
zj5qSI2=k%UGi0ZS2m1!BieQbzdow;#Nsp^O(DUed^zlbgf8J?`fL(-7J^ueRBY*|O
zaI5Wd2-KaN5y6I60ADa7c*RH84wiczN44I;<{*pNY46&=iC^2;0BC4v2+$3b*)u;+
ztW_8u7}!gO7SXhuCy4>@;P0PcFF}s%qOc;zvuTeh6W}!RVi#-3;_aka>;YNN?xi;8
zn@FsH9`V2?_W<03vY+D9Kqp={ZHGvl+CN<mm1<<ycDNz6ZyGhM-LCa)PvmH{u;qv3
zSq~TBmleejU235jd-A!5XwqfVO+cSwn+Soi-aV3OLnU4`WH0O6Gnt>X+vN$~UZSNU
z!3#yxtsa&4<nt{1uPm~w0*@;^1~^3%?<K%)4QD`C=*K%a;Gt0qP!&wDG6iG1hUf_J
z?7$lV9j|3?AJ&@r4Iup|Zue`g?T)hy@bL(E|3ogIYKdB^T3kFIT+kyqjVc;y_$5%9
z0i}t+EB|@T1Pp_UraEK6q*e_EYhG~3^YH@99u2(p(zX!OMGr}QkWFq9yrAt=!Dmpw
zgCW5MRx7}_N%fH@@1?1eejPZ#o514APvQ4%$RSLe4^MV0k2RRG$L@tDKF&a68mC^c
zf#q@^z&6<AWL`+l{l*rU-!`6-iQ4%POx#d`r7BC*UcD`4ChmLqKHj`=i)27s?WFZD
zWIzu}7g6^}C>APtJEd2E`({(Q_dGTX3vA7F1{etI9p_Rg7;NW^<YY=O#VWdc^40HC
zX*6`y!1L>22mM}w>65?^jh59b2qbRF(d&sqbx|N;;VZ%@i!AE|{D>Y#73+Cma|>%X
zyXPy|Nbo|@RJ7f$;jWRuVC}^t=;LO-dXu>Z%vxu#GAo=mIN5Ss6PQN9*&X2q)$amj
zM<>8XLD(r{u&&_ko(L{uCcmMY4MbiSq0ta9;|tH<<!W7ok*h~QjH~sm*`)weCFQ*S
z!ktrR1xVW={j8A?o=~?Q@IZ?IcI6mpUMLBVxSPBJD8NR{5rM#(vE?X;D2cv>j|$+?
zF0m@nuByy}Vh7Muc-tq8C!ueF=rlvZQirc78s$qq2x>J?NpyBlO6%-;c6ItY(va|_
zt5CgMh(y}Dp@_TCb;<H22Lp8g)o&I4;9SHG_fRH(73~^OT~78L*ir1$8r)uLw1|)g
zJi%&Dv1TVjEI2uoV!A|k^MeO0@(Y2*038aUr!_S5KwHBQD1lmdh;<=a2$N^)sNW$;
z%<8Qq-3&dqY9JXncMZDOICWDDCaFNn)F!xGv36`G)>6Fm+$%Ku<1ad`Vu-BkqSNZw
zod{!UW2Xi5X6Gk>8P%fJYXDG)3{{B}%u3VIYgCaFB}iJKsA~|=&MQ))TCXm(!M(qy
zhAt!fPUt9@+6WBjEFB3DB)p)BZpX86VJ`}gxCb<*HbMp-IIV-T6&@_fc1Rp56+wW9
z27et5N_RFsnJf%CzacoJwp&9x_d;6<0=iwsBjH!baN&Y0C0uGT_)gP+uisEdTQgK8
zLFfl5^3q8JC|;!e=Z6x}KcyJt&eFgR>NugR@z<GxKJ7{&*MyNRbcMRc0f>(_xb6Ul
zgzuIPx~qa&PD<iKnwr!R*3h4Cp*0=(=0pP&>Xru3qCCL!E-E7+6aRd*85jTv$k4Dr
z*Fr(dRNqVo>lNEAYY}%_LqZg+1dm<2o(4R7sbV!6Ef}&At}H}7A&M2ZxP}30MT<P{
zN4&_X$1r!a26lJ{>U;sUsf}>!VMXADU0!Pj(C>GGu28M|xK$5Xv6vF;2wE`6hQlXY
zO8^fih<(6cShy)30%UN|7TF?hp~(7-=f$`Z*m%J42r!DUzeEGGz-mxIzfm8y+p9L(
ztqciWO+gh9E8IyM@YPQ{(t>^}@JZhXm=BQXDcX-{(W@;+X-8{dhju2PW3b{0Ppm5L
z(2G89IdYvz46ks3hu4X*>p@}Y!=00GRMM!!Lp)ddfESf`BH=aTI6Asn-#Ov{WCG#V
z>10F(aaMjjze2#a$`w@!gZfpk8vGiyN*;^=v<m0Kpx_0f?d_b>00AsPM_0+rY)X;<
z06+jqL_t)*D+7qPh)Z^PLn5TGf#Sz<cBBTR69=m>k`@d}RIe}$+Ce~r6a^D3@-n~T
zMP5S;GYT3|{UYM#QUs#Fi(e8Us|)~uboc}m_^T3VE(-EPQ8OmYT@Ze7{4v!5C=9lq
zmV_oK270WQz)lh^$E?qpHcLXsV7P%crWFhW!f&%!D^@t1C*BNRJZTyf%!k9Euydx6
z?LA_bHY7}u?4rg}J6QwPPV34_BrO+;Xe2b5IR}~}>B@blWrh;5(<+V;_NxKuAC68U
zNk`i`l6LYAe0yQ%rNXUN$tB~80~v#wpCH}{00&iw8zsiEO>cle=t={i0y0!xo&^fP
z^$IL}f(3Ai=?!d;#mm#|d@Bl}Wl?nqBn${lVc`4;=ra_$rCi#|l2&xBG_>gvyuuvk
zSuli$F(I@J0%l~FG$h<~Vu}=t?NAMb`c+wbYebBBRnWm+;6QgIBjPkHBrmbTA`%1M
zQ5p!he<=8XW>y8Az<7s9dm=*ud^`bsNW!=gplcopAO>i$<1Be`9ZFO#_ZVYs6meJ=
zyb^fjH;>I`2!ih>si=)<VH!hTGwwr=u)i?iTls`1BWTbnk|_^1fplZS4a1#ILT+}i
zyWGI7c{qOB`T?n_d<rG5OZiQlC{t;iL9XJRQHD2v;^=17fuQO`JXY3my+E(fuX=^J
zimSBJ`?AH{4yWt&aYr!Pf#b^-ui&z=+(r|nM{8wT+{E)LJ3+?-%_6Oxg(m8YlqUGJ
z*M}!1^cVEqDO`p$_*8M#msC0`WxCFUCjYPvnjBYp*;!?%7ww4;f{Npcn~>sbXY<(^
zI`bnt?#z&V9P48;`V#k-67DZ5ZYyJ0RR-PJbQYz4wp_mtO1tPZ4PLlx9QSLLR=j{`
z^lNJwV35WKLB(+e@7LdSjr@j}EnP|DP8m&;Z@5zOONI`n>!)jRyrT$ZDs3;*@TS}V
zI{cd+%D=H2@LME)>D5Yp_tNon{j@8k?vf!)Q;$m->YH{ogR(wR-&E9R;$4R{V**db
zmoH<Q<BvDq0A0*w*YcaDr9Lhji!wcZ?UXAdjXVTg<->2KMxB%Ry-v7-=2*@{nv+yi
zGKj9Y=2ybY%F<PI+zH3fWmjJ+=|M#Ujrgk4G8#ShSi0uA%LT8P@g`o+aSp3iuBPM0
z97UI3b+MEU9z2lW_r&x$tSDVUqfZ>ouWpzix-J@0L|0s;)xC1XN;+=zadi2W8qGn2
z2N`iG8*?08F#)h~R8&+%S6??l;$^E=(eYe%`2-I<(A3LN7wX3c;luYo6g@!pczzFx
zFs#0HYo*hU$OZ!)4d^7Xu=6xvJ0ja^RohtVXe)UV)@$h?eMavf1)H=X6QRTjNnqy#
zgnLZ%&gVFK99U(y^&6E4*1ldadcHzMQpNppu1NcZ4+~Bw{-?k45!shd5B$CG@zcEI
zKa3xel1?Ms&bu$#+j&c*E;VxF_=xOyJURyp3@C5FWc)br!0<Y&8kQ|#5(>x;$S`3c
z6pD=_vQZQS9)?UJPg~%q?9d^OFtgFv2-&p&;|y<_#x_xFXy^BX;D~JN_EJn`$a)A&
zXM_{DvNo=`h2L3&kife&68O!t;Rb9Wz4w88<%n!(2_BJneyN%YaWEqEoi%o86vR%x
zhN-rl%<XPkz3Tbu8X#t*t>j6NYlxJl$(&H=I2n^*uvjorg5kx=y1WK#T}UNDwKvKE
ztKc0{TC))kMa~b5ql)m8R;E0$VFF;Ipf6yi;(!xD<jYb+DCsp&ZF<98aA_gn8CA{T
z3DA)OCLY#1Ojv9f12|S%0uR1cV?nVZ12yYS8C!-C0m~)aAa(NY5&b<Wk&r-@vK|9h
zodDkCY7b@`b}2(50+re2ilsWP0kdy-&<eMeLJ<s?o}H}#?0^hAd{k1QM2bo!F(O??
z13R(3JEc2!3Q_OY!XVj>LCEV|2yax3VqA&=7T=u_!lMjmc@XD_p8*;?C*VkFyq^NN
zf{$-U(B(uf25w_#Mx;VBo*(`kT-cL(-QWd_FyRsM3SGjGh*VczLdEjK(11&ywqu9e
zI>88rOUup)Ql1n%3j%3`ofAx?u!+SGy1E7;>PlfEIlEMt=#i<=M<re$9UaQWn23yP
z{>@_mb80L?Vo^eaS3y0gdy~|>IM~6_+`^iL1%kkrKz!B^kNnWTaXy4sV+fHQ_oaCz
zz?*4EXsnrSVwUVUzKoi{Oc&9W!P6cQLHnyufWWF%!fhE(f?R{58Bm$;3{MK41-?n!
z0hJims~sYi+D$bO(Bu8~tpLQ(3R0xiH8e&CAtK<>tPwwkjs&h;2FVDSkVoqXaU)?n
zgt#ci19}KBqh=TgIPp?RAQMH(s8CQSWY0xB;P_(ztMZ+E)p)X)3l9EwxJN=Mb0_O%
z&#FFXkB_uPf)Zu@MoQOg8czzI1tzZVSST@k6N&-uiW&&ol|uE6pvYZF8`0ns14oDH
zSo{)U(c_Ax?(kM>bY2VS>l|<zq%WPc^MXg-R4FG&vL5jdOT;oRgODsJjc@5Zwj-tt
zA=O6_(d1C69cD=Q(zoI&cI~(ZxShR2q^%K*XrwevE<;iX31HH4jRj-h6=4_6bn0nO
zk$Xoqms7txs@`zxi3*=g1pP;yg&ZyqI=q+=@GMyRVt8hOi!j1hgbZ~AjqAl>Q+@-c
zh2W8B5&6X*AqzGG_kBP{cq9DN_RB+u;o1YawbJbL?Vm2qZ>>KT?+gvN_QOb9!j+iL
zb)+;+p?y*C1!U4RV!>E9fOf-(Q(t?k9(**dQ&mAx!U7ITsq+gX;MENU1^_}k2El}+
z4)Beqcs??^U3=n=i%Vn|egdAuy=i(B*|Kd3lT<)<K!z38rO+iyVW0@RDpHeKh9GbX
z9#8Y_ENe?kD>XN>{A`3^3L_;IXEIm=|4`$&Jg(K6xl`l6`@`?(_FI0#Jj3Up2`k$^
z`Oqq>QD}3nM4Mw@I*xXwdm=py6xNST2WW+GTEZkW{`3<ploTE7)lwX0R8a|v<_pM$
zf)c@{Xt&RT&Nx_Ar)OyeKEBnVR6am=SrDs!tU}<xDO*s07A0D<RNRKMGZPUq1T=Lh
zl^gpgk2Gk5EmN?q`p1v7>jZTul^>4e_7W!h7<}QCfB^zjcr;{s!&V{dsGW!8Flj3i
zXd@VA<{#E&n12c`>??R;I%Z%79Xv+ekSG~iL}U0gFMM#SR{|ds8g9tzkxLnw8R4Ss
zS@38`^$Cz%>r(c{4*+sx1QOFuvsAPk;2z1u>?BI=mEuuKl-fI0Tb1ky!38c=CKsf-
zij&kMnd{>+#XhckXi#dyRRtASWhy_|b=+xI12Pz-S(cTaK>6JEUZEg2Np7NE<zD&u
z-IH9O`tq_831xnRl3!iD@C?~K0FmtsN_Mw0!0r&)J@|F<8Z3R%sm^wHN)-6x%1lV5
z?n&vMWb=|U`QRxY%$O90G}j-o3wBOYh7NBp%uY<FoWy934VsK6jyuj?QHT_FUC8uC
zph{dYwVM-kAd4=gO1#s;{#36aV!UJkUvxE{YNi5)a^S*qfZqi^Dvm3>Klmu)g0p-F
z(@fB`704WFh)U2ZAUgK=BWeEwM;bK0{A>=@*Kaq{!6IW$I+n(sJciQJcwpeLZCgG4
z=H`11{7bI5koxxTLr*;PEY(!k1S4fDixkgBWM?M=+s=g})e0^}0a?KahC@dqoRpJ9
z`@eb!C3e@`b<I_cwCd4P+B{>U02H3rhx%PTh!V57oEI9cxNixSzqVe=(gvi{fa%4Q
zb7&sbEvliPFZtf!HviN@8aS<(5;Bvholj~je|;UTd|;WBkD7A~#px%uwQOyovd2ql
z)0-O%+&w80w8c=UH@AWd*81V-t$Su7y?9dzWo2l$k}Y*D^vqiu=!5UK3YpUn&!fvu
z>P6kscrQIy`WUz0TVGa5S-<>bns{n&I(S$&TC%pDCUSpK;iQ9eXyR#wl$pwJQREZ$
z-ubGE9)CmYFCRQGf|BqGWezplTIgBsWAA>wMMPBcDLN5dJ%~87A^Y<;I%I!)1I^N9
zKMk^vwaflC%Yo3ZXEI%L8p}Sk8!d(GkD0QMh3wq#mFzR-n6kfrzg_k}&)i5ezu6Lz
zm<q`$mzJ*$`w|xbZaj1v9XK;Fl^z~)5%o&R7LfG~Tj=@qv+0}a6_P$GXBhoo;Stm`
zC5u{lz<gx&O!|Dw62_0C{G=?pp!bn<Y|aRpTf2(xUHM<Z!Pg<#MKqz$ag>+bjT%~;
z==IIt(Z9>*Nck%xuBB8tqM4|?v6^03{~67x)$Robfv_U(lKUaiBfkfodG>fd=Dvj1
zuU$vaKJga~&7vb49X34F`4I7~+QLidC7vI&1GvC60;V|BkJd&=OK3Rw#)shpyap~v
zlEuc0Or5j}CRS{C1}r9(pst+2Ss*Sbrm3N$gnLn<D7=@RdxdVBem8C3-k`F4T~kt$
z>9n)P6RuzV?;HB*hxuYqBqo_p9XL0=Pv1gHP4#}_b*n5=JU3c9G!G4?J|Qc%G`1(K
zBIeQ)q+8irbH<w=cv5l}#PKn#TfeTNAJ6@oz8m{LYFM+Kif$Vs-UnFX1E-eImd`8c
z+habXijOwY;9G`LLIzvVT(-~O52W;>3~H%s=9k7;x+L(Xmr(7z8v6RMPighjE2!YS
zek9%rW?<z5OX<54{zu=A{+w#(*U+GwhY<MKlY%_yL1gvu5?+<->d`N*&@;nmcQn_x
zOY7*eKQ5!Q?_NafDjI3(*?q+O0N!8>e6_HKPPu&{&HiaCO+K>^Wu$6t{0#Sr!G)=`
zt)Z0?Eyn-@@7mJ~Y2m7RI`QWD^ul}PbjA^R)Jyk3Ji!LV*>^3XGk>#)7Ovh-lh5eQ
zo=?lb=PH%IOfT8p^rd9K;=yHf?mdfWJ!C(t4?lG>FOZ#$fjKPusVw_v^EBDhb=jYW
z?CfQO?0{E6WM`d0_OZ9H?C+Noj4|bX5!qSKXR`bY`8Rg`>6+{cza!Uo-*WlAo2)Tu
z^S*)S+Bwywbk)ND&)#(aSW%q+@A`4T(R=5piei`8D~ct}_>XD!3SvPqQDb6{#$IEI
zF(%PyVz1b1tSE|t^xlsH4i31={lDMLe!H{#X7}xT_wKj@2Hx$=eEpl*o!M#oH#+&-
z2WU}c8C}r#C_VbXuyK8kp#PQ6qF+qCmnM~cLl^fwhC2Z~y2Sr(8+Iy{6m_RHH5HU=
zOm_fwPVd9%n~KGB;?%q7k!A1EFT3yOjzHYA_zgPwyT8zHzPq2k+qjs{?=xD-YlzLD
zg;lS=`c6u0F5zzyb??!Yswyk>sJlE`g`r&Ce2#Eu0;4lId_*>aKJ5|+!GQaN9d84<
zs3;h8Ah<153n6_4<zgj9n0Gz5sr7i_OGcybQ{kbp?Mms_2*FI@8m2-eI~Kn!b%_f`
z`u6Wb7x716mM&gKojP}-;&yFm-kb$=_pJ}mu$_mh1t`mxtsrzp5DE(msk*v~4j+B6
z`iKzH2v=Nv3BTQJq5nSdyy|p}yZCGxI(!hHVV=tiT59S0X*218yZ@#>ih}vxFuIYu
zkDwp_>^SPut+V30WYJQ(>DoI~e5?MkmsOf7MKKF2MJ?);=U<O4v%0jJW?eB|;e+ea
zM;FqtJ4aH{&^DCE4FE<C7C$hbYB$u<B7Xbod}KH3bVOHL#c!|E&YnUWXKbKd9@|rQ
zBpj8q3$nShkxS)YtfehgTWIYEtEt}wgQ#d=5mm3K<k1QJh6<r&Z>^#Z2Xt1`992u>
zjesd-TkxOI(hC-OD5Bl?RLZ?<eJx%8uf;B-$KNWYKb_g12KOqYcHB|K$ibuB5vbT)
zM-RTdf)3rSJsq@bJ9>@ZqA$L8F3nn6N%vn=;_FBha$PAZ$f2)hS5S3rJ^gRmdOGXa
z?$p0~0j*kBqedr0;QL>f)2QKX)wIg;HPw=x+STySt1rZ_^RWHK#|_)xE~OjK(6$$g
z?c5Ql;LZYUKV+n~eG+WHZ!XP-?H88#IuZqr?NjDx+dqcw#~8Nr=!6Qav$CB>b1<cp
zw(W+eJlh?I7=F=cUd38pyP5vB^gWmQ#nP{6RQo~Hr+}xWd9(r}2guvJrJ9~u`8gfi
zWp^6cwjX`Eb_QKB`w3di9gjbhoX8ys-Kc_5F0UcznAe7;aYv$t7iLc7D?;~z_O!Nk
zqw1K5N*MV#yyFPf$tdFvNkhY=SKdyE#l3evOe>Zy=Z~13YoEUNT&4LU&ATz6Kc+Y8
zxEG4kE-}4<lP~>kI%A=8pmuKr837dyJUS7c@3fFq{^|}zR#puY=~Fj-)M~9ppnDK9
z8UeZhrjM01Aq8m#CdtHT0~+;`!2{h93yc=*vG+)tI%S%o?$NV5-E_w_^z!qQ=%e>P
zQF-M&jj?J)shZZnYS*%|HB?hwL+jUXQ1F3+`qQEXi)q!$)wIiQJJT*Bcc%Rh8b!(I
zetr5$YSiQNPrg*690LapNMb=FgA?maOo3*pL@_b(lCwr9EN-I`<lOPlE>zDq$|i0M
zib~ojVY$V5RJE*<u#N(ufZs;Z>)!aiE=QGV{Mk~uMRgE*bHkM1wSYPv+?lFZRnj_V
zco?W%`R%P84+TSB#k6wTUOEwmoBUB*@k?HykdPFR$t0C>H|Y>RXcr7+*VEi(o7EdP
z@``y{V+GYvJ6=bD(4D8j5YUMT2Iy2-y@f|F%IW0MU8xIqLigXfm`clQ=!=<NgK^Bh
z9cZ^fZIrwji#Mg$kOuq#U9jNLYfuBv_n@+Y^nr%$1F)ut1EzFfJJwMki0$Y^*n+Zs
zYB~Mp$gb3x@00yU1Z-!WkKy{h8{bp#b=tN&!c7-w+j&%iGtGR_6M44!0{9-q{i&Ki
zJhilHE%nUmph#Nh6sS=LbSx0M<h5nSS=@<Ot<u3iHT=o#S4*eRuX^mSIuxVY4Wfmc
zOKHYN?}cGh@n9O(x+fjMoruZn=TZ8d2)~6`Y&q#w?o5Ok7*KWzzYJq^Att(}<`D@5
zNXCb|s`>d?SIg5I`Fh=g0=j=tUl^Y|ROWV2J?_@fPJ{??IwV{_eTHL7!`P((Z2f_*
zaBIOScJRACHdz89dSMgCUrEnA`GSIt*mWm0it+g0|HIp3_@?8LieH{`B3*gyMBXA(
zK$Ab4qDBhVuF><Z58m^rN>7{my`sPUrhC=MMqYj%ZE!jl_|$6@9TtINEe1L!8!I-_
z^H0A_mruAlLDxplK-tJIC1EHH`3Zxtf)>1#1n{TCM@JF}S6t0dyjOc};Cs@7JLd4Z
zhI%#HP`9a;O0F8F8vH@m4Oi&7?UMIn*SuRwIs7p0&co#eJzG)fYb#7q)ZxHR)Zw7c
zl+ACjW&Ae0y@a68W7Q$4CWe!w42>*qOry))#5Lo)@$}S~eLK=$c%1<6bW<ILP24HC
z^yj_l0B-bt_sc#C9qTDXu3P~yZTjfDa^7B-LqFWF6E9ZGr?<ZJuLBr0yqNamMmC?{
z;PGajaxjG%#Oc~T61MNtksfetM@K=~{(o#c>uK6<h_gmN`qr?$1Ka);+ip0@XFGSe
zG8GaRTLw5g4PhXc1{ZaspLN@Z?qB>S)$!XcMjOg&Hqq%l52jt)^r5qRAErpKFjF^#
zK@MK}%ZdfmE~ki2=(;yge{`dF*62}A!Pu?1A05(RIFEW1&?oB}vOYpM>MIsoVtNfz
zOTLQeNAsm3*BAIOjRe+8@XeZoDGrQE@LPW3?hOZDjW}TBK&N$;MJFPqX4?>Mi8?ae
za&bEmo(yN7iG|q9^02);Yb@lxv*ISpTvNtF)%?~nf8Iic+P8mib^RYN%$zXx3VP~a
z&!`Rs)<f*Q?;ertFv4;9A1A0CB75$=8+Gm0Md7z9@;-NJV^GIaFYmtjfdU<V)FE{B
zpRS;B{C)c-3GzS>YxhHykXmk*M#@Y=xyJ$6G%)E}4Je|W?%$2d-d;&7{=Gzlm}u5z
z-|`e;Jq_iBa&^2QZ%bt@VLBu#U=79K8+N9pk1eE6N4-bW&znNMPU+7bhfXfp%uBzc
z&ky{77Tz_7`dv7PuyAu*4`%5rTQg7v5_qQQ#D2U}=T=@!`vJdAKl?$M+wNWS_l1}m
zrfW{=N1J$h3UAzH>+uHUg`oOaM{wn@`qGo!i9G7E@92^T=Fu+>>q?_`;x}3+{DJu%
zclk7WkQ?rEj_*NOxEU)*1&)Or4+*y4a*ks=uLF`GwqFg~d2~(L&Lb;P!Dl<K54q$)
zw*64Hou_Xk{DJR><E~`eUuN5nW7~P*W;(%I=A3EEx8*@*cV29H<KUmuYpcJe_txqc
zJLKQU3n<ah{&C<5w5hI&Ht<x)y4p<)3FE|5+1Yt?)qtPSKURE5Cw+G>P2?$%(|R3D
zJGJfwmMT23<SjaN`U7;&qSt9WugSo|%}j+{o`zHFTVgU){i<N)jYEsh1pjieqmk+D
zyEnjyeI=a<#h07w*o!LTC?Yr*{eUc#4dVD20fr{AGqNKAw)mwJaQFs7N8ZXA4DH(M
z!tdUrn*yy|v5MDBbfiw5I`RUPI(q+||Ir8Ueym^^SqKIU3rRTqsDst0!qO$nY5Z9e
znf4<AC0tE90H1m4MYS;W6`mKZuBxV;Mhv6=1N$b>H8=x>VE$5KD5W4JVKPcmx~lYq
zE+wG~8H+7V>B%@@`eB!U>_rv4@Nw2}^;DH&#A>elWG#LB>&f)V-tW?^-%X?J!d%)k
z*Bh#~X;-|b9wJ@+`YHu3=ecD}m$V<1Sf^HTgM!eW7v*giK?){W6-dDu!V(J(la)2t
z3O*JB-ha^``hL+Sy5=8?d=fDoaW0Qc9e(MzbnRn{c$6WV<}I)E-3~!n7}-F0`zt*H
zIc4@nHC?hd?{El)*C%V7eR+f;GKjK~NW{|`JhbnGpk9)1Uc2!0!@b;rox!$W`%k~^
zlX(&9d3VmCBPV`K*Rfxe?Yy=pD!8^!VY^s?DRUxhcXo#)wLMCp!1xW>y4aH8Hb3Ca
zy#sIi{PW;n&{yjh&_he!6;A4f0n-uJ&U=ndn0hDug&Y62xvgkP6|e7LIvYO_58?%w
z2(t5I_NEnTx@1Hf{i12oeZGFK!WEcG#QFm+CMQiKi!Jl>bY~(KD@IEH_QR+I&X&kh
zyIL?ZVGrm$@Km7cKsXJ)9Wnh}@RpGXHKh??rFu+(yg<@Aww&nZ09A}++3GSvhhgl6
zXVQ05r>k8UXsi+Pcqhi?S5KgB-MXsu^lxYIx`_dF@)^INIkV;wMlAN+XEz0tbrMKm
z3IZLDGsm8y@IL<VGb&rnm6JmoK6m1PgGbT+2aZx{^N)>g!MsI03UN7o@#$BzdQ}-!
zFz=4Mh9i}4&6_f;@$_pMvkR6&s?37)Rt>G0LMc}(QXn&jx5AD5_uf>`bAAhMpF^#O
z=yeg;y-~NRjymwl^9{U$9a9j)@7|U3YI*UbetXN~GY0ZH<*S92_|ja_;MP>Vx|+&)
z7YOzY_Bx{<&AV;}b>Rhf*ws<`+A3<zi_9>Evih}^l*9AS{dxN+LIp2Q+b#mCLn;N7
zVW)^_?7(=Kx98UJ7R|rBu!2f>`U$FG2LnbR_ElRuH&Z_Ern%{?{%W}Y)9D+O>K(Yw
zbSTc{g_ZiCo`HPE$QoY2_~opPYOCmPj_5+S{&y)Ixkm@}z<rAwPAuZwZEzcUo8yH{
zcRuf0K$yw9H>^PvwE`QK3ELlXY`_0Sw!McQ1zlE_X#0(Z?T~7<ofjg1$(<%_lU24q
z&9?6zu$|Y1po67s=dH5{Gx;7%HMnkZBgr{nh+9=VrfHR(Pd9TX0_!54Sn)CSEO0vg
z)f;GYeI@POx;HJZUdyK$<j{nE$Ec}}=@m;^NEWr_sf*&gLMq|~nYj!H?fSaSG;7mx
z)u<lVWjFfg@{efmwk4FGolBpU&!IkrooEP8b$n4ipYw9)q;C5ug%@nLueY#UliXNr
z(ahtzisu;C`h<lxZCg`uaa-PHSfJ`=_nzH&TD?NGQDHQ;{9JyX)j$@%AYq!_9$0VH
znP4b-aG4HlX1zLh!egwYgm!K`Jc;=_5}8!--~W7ues#+KsW<!s4*mgGpDg<P(=U}=
zYz^(zyQgv-oc{%{f#}LRC#tKfd0(z>5U^I_>o2F$+}ZO*S6;{P3Y|6XRNi*eP5oB#
z0?hZ``jAHR{1)<l{_7L?e2EQ|&m96Y*yzxaz*-D_=#m~@n*QAkwP@3%O*<Z52P0Sp
zOCVJyLHY<$0g#On^Tlx&TNafRxo1f1^4MN3_gR;JM`drUQk{XeylNexj`#jgJ7)@N
zuL^z7FHvhMbc$%?ll#)j=a$mE>u0JhpS@1)NBewmuo{h6{U)!1=izfKu<Xxog4kAy
zP`kdGcZw{a4e896i{KV;^_5eq)gz{TDEC)+$Bs`{2<-q~Fe_(B+{Zf*Bw#1UJN#Dt
z>m$3+i2iznVN+EdU2^|CHPr#UGmh=X3kSW?rN8o4U!0k68+RTaowS0dGrG{rJhg=f
z`g>omqv;Db(eB*I#Blz3Je`5Cfp>#E@lGjyJAb1}yMN*+?;?8<Wjl{hCL;$N3o2dP
zFYs)?fp>Di_Fr*FXlK)Q-o7j^cV`?EuzdpC&K>95xbyJn>uftO9)9^c$9CQ}JDo>7
zb|1vHAIrA0{Rql-p8iR&T|vYDgxQ8Q5@DkfL2j7RkTWFi9(J+|zIN`jG?^RzA9dY}
zcX8-@6Wctmn)_eX4M98bV_r{jV)q}oH1`ibjsCmxGkSc*|LCEm@6gY?kD_Bc@2)y2
zudJRz3wUwnU>>a)+iNuC^wEuNY4v(_ZpFMxJzD893yp+XtqHJ3;=MQCRS7Jj%;S%2
z;oO?AZ)zNS{Ae1rpZA;_H{m>*%<bC?PrnqZfenD2zu3Br>5cljT5c10)PdzE-r71(
zA5YDkGSQ(>LK0Vc=!KPGBP2E}Se-$Ac2Vr2+<gDvZl|%QPq1@HAs44!Ud;P%vBTol
z8}H$1j}B@#hRLG1T`?85;%#2sNk}EMZOd=KYy>(csRYPtTik}Q?G)Q_8Wa*sKPEfz
zemV?<Hl`>CEe_RvkKRV(PP-&E#u3<seT&r1S;a%!sfNNnt*CMdzj+xh%HkWafZt-#
zao!$wYs4wDRQ+nhzn9DX{E%`t+^<OE=+v9%@N0M*=gPIw>jP}M^yHIEmzPz$4KQ$U
z%rH)iM7bwydyJ!yO^}m!@88(=(=UnaNF<6tPT~U@EPJ#5I8aM$5Bkp$tDaqM+=--Y
zdys)8?bF>&=*T^Py_GIF^HLv`i=uM5!NXY){!AZ!Jr@eTsgcDa30?ErQ60zE@YYQ;
zY~d}T>PF@>B(nLN8#acWcpK=NnvJekArcL|oNB3dYeeYb2XV@uVXC9zciwjc{qCZx
zcsB(WTymq$b*q*;u+=<8FP*;xBF+HYe4c7Y$0OYU{y3Zpbt4b!CX}ww+38RO9PTqE
z086Tas(@ZC^kOVd8Ok|^!PnjLN4jd_HA&gB+qO=?c@MVE0#2-4pT<Ju4I5JHK#0{^
zUIT~2&C(FYk=LNtQ)a;2gFGSyy1-PZ%=u!MK?5R{{8p82z!XU^)bj({mLJ617SgGd
zTSM&)mOE;v$d_v>GL|G+R2#)>8BcKq1EwDn^3zc)$e7c~)`xgvyqK^-PVi1%V$oml
z)isfg3r?_+Ay(U6ikK0fOfQjqGy>L{wZSG&aEMB4LY}LxqtN-nE(T8r;b?B_6evaq
z%zVL(zB<%N)Rr|8;Dtrum}14=qIzfQ0pzxTeD&Q7j-=YA3qR1Ib6m^MGpv=sW>Dp4
zUbmolV*NsZIpivx7~l0@07v+%E8C>-@mK#>*^q>elj^b<9S9$7jD&A$BL;qhP_Ui>
zr&eM_qD2Q?A}N}HA`6Ce7}@v)`TEnTQ)v3Q(;9whJ5rhUK)U6Zt{#}yFhf(zH)SV{
zXIMF$ArZz>=SM-&C^`@Lq>48lLYRhr!xFJx<&!NFbNzZo!_h*;d8UC&96YZB>(_!)
z(Tc=D@Ug@h5(R-#1+`uRTQqreLPiXHL{0)7kFXAr4d0fhrc-!?6>>1rs?CExfh||W
z8REFFj?djd$5M3!&>2ufni7~2R2Kp)pr<MyTs0JHG}P`9K~D3U{&-9p0<nk^r&eND
zMvDw^zEc44^hcq}Pbh>*DvX3jVkHr-=GDZGM`2QXaZGLO2wTqsQjY0pAhhX}Kc+TX
zL`cWDB!*#XBRYiLw_*8yZm!BwKz?w8QjsiO!Qmn>wPA)BBqqAo==pP#q{97{vV0{e
z(hH%w+;Q&>sxuHoKqHN_N-$y&7Pu`}4SE<nZaz8!kf$5_Fe(<ty#S0L<T5VKzTnjy
zoX6`qc*o-wUT5L^@nTrj6T(Ob^T!rfOrI3w<?=3~yo_`rplOqiNQAkjS?7n>^Ayxh
zl}UJ|jS`w3RTRe^u$JZlTOE+RRBK_gwOtHqLIpjMUd%5Z`S7qFCJyyAqY0*;KK)df
zMlMH%U`kC&;gXsWG<2bM0TILOc<YT~&oG?)tZ@+GUlhKnKx8}vOhSyqXhA-YR#b&7
zzQh}U*rLoxl`TMQ2gN9Zn$57l%`9{}aIh6Zi0US~iYsjIPXavMj2#_`D9^<$9hZk$
znL(Ti1C!Qe7#WGCfb3|DNaj0$Th#-NQF7p!N{!sA4hR$87>)^(<;#yFSa2LqI~T=9
zKt7)7Ct|TnKr$6dO}1{Y5*YfJsCjnI(O8z}k4ugSe!#KUNEekc5<&tnAtQk#<qV$A
zFdv_K>Vdav@`C(?P6L~O#$TC|0aYL?)euRM2ESD0H|f+ys>*E@e5u>^`W>PYiV?qb
zh=n$Ubx5|o;-n)#M8J;h7Uuzbo$#9x2ggs*Oj7CHCMhW&=9{qmDCRCrh~6$dib)78
z7OjgU5qUO9I)u3`I}QntM##jw%<#LcKp%&PLy!V$YK&cl?2)KPKHmN@Er4H8Kjm5e
zlhDDii%Fgv6p)-E8bd9Jh_Wu4JPve6M*?0_HNm;Y@tTW+5|>g>wV+H|mtkZ?C`6)%
zECwJa9LvMs5!=>0kXR?S5eua{w<L3v&dEz8RnubOC&)IROW`^NA#U1@L>B<2Gz3+y
zio%z0c=+<nXP5Uh4VC87BH|`O(R~2Z6+VEGz(@p#dd$DzX9V4u;4cze4vqq*>PYxW
z4C<{Mg<h&d(Kvc+-yI3%+;ki(l~@?0T6^N%03t=Meoce2?O1-A9jTV!fq1pUvm{k~
zkFuG^n$WOlQPEJJ7Y$S+>O)C20X~tu1i?j;=aC6;fvJj*maVv<6QNsRd0&r~7Jxbp
zTp%|>&-j=TOcFqG+F4mI5uAR&0?E*mFr_#WByNR_I7X(S*7nzt2)4f|I}Mdsn50S!
z+UT1=Fzi?&*Q}XBk*Y2`@V8eF*y~m^@<ubN(s6yIrlAv%rCE*kt(Y5jjigSHDcGR^
zL5RMJGA@?G&%#!pgy<sbi1~;LfROaFNrLR7_fz^nnNB#P6G67v!BLQxqjo_E3>Kgx
zfq%YWCJ{H&Kn$jR#Eq0tor%l}&gs;y+tta`#WB+65BNBt5@Ghtxe6v}9C0o2W((uG
z=<3Pw*)!ONA0MUlP72efbK*{jPnYG$8_Rc4mO-b}T9>hE>yPlf=(jpOWLOF5xF_!-
z_C1E#Kqq*Kbm_ss55B+;LE^YVW~Sveh7B!|=NzXF!oR2^gSl)kbmA!6W7z+a4#H42
z7dZ6=Fo_GDq)iy)nLNQ8Y5Wi*uF|ZJ$QGWG4(bB@jKTOO!!zU<e*P$)oOb195C-0m
zfuFM7iR*M0`|~`NKZkW0!^ek9dNALc5_e&jF)lwF6imfE8!os^-_xoboVeJRHf$pE
zgkOeoxjXUMGw0DUeBAW~6VHPx3}Zc=xRPhUkPlq>ggCD9<6@`rmuh?FFwdhIHvW>c
zl`jSl8AumQI7`Ln&YYuQ=U;lRuDdL6{3YioKg^jmpT-<_I9-4*E5k2}?rc<X{$3K7
z?eSc9C!DL&fQ@H74byazc45q94u3Xb%&~_v?wOoo+ZCOT3+#M`LEs>UNgS}FS(o!K
zVi*g-^=RgUAHwJ{htXk29ZH9dK2)X87<(FXAeujS0p}e;r=NGKN)IUM&)<7GO-*s&
z6Animb2yFTZ%QGQ3?4{ljMaFG?kJ{n(gOzdcjNQtFi#W4JcYkaUZcU-53am(Phq!Y
z(dm4Jz4#%#`{w)V8uce@uyaIq6jG*+$c~cHsIbg-zGA3~>Ib2?hKF#dP2q6ta0v~A
zWcrBghH2CCsT-pN8^Y68%i!gxBeEN{6dGbo0~9mG-oxiejOQb=5p=!@O%#Gg&kQ!7
zdU;;Vq)9ohWCjGM%)}!QPIt=@*_<JHz|wL37e{29Aq(dd@WDt3u62xBpOwQOth5h!
z;|Oj3u!P5kotT~F=j#CxV}@G1KRYB9i5ddL5!siF|2-A*nGt+)w;OOuLs-CcMm2wM
ztCn|iz;>|4QQ3KX$P*f56$IcqM`x?QA-WhCjT=?+qm_tzM0U8B8rOuz=Z=DtU*k(N
zBuK%?)c`qBK<rRcVZoAXBA*>O&C>%?V!>;3(-!(Qiy)3_7Rs1P*gYg|gj|zR*twWg
zDa13%%p#Zhn<C73A~vs$NMp`DnrBc-K%pQwgK6tQP=N)PrZ{vK&}qQpOR>qiPQuoS
z03-8pZ!&JGxY8?3xzv={_Bs+<t#DA4q&nFP!HyvcOM%+4>>PLGHU|$#iOIF8bb`DV
zADXQZ(TdqR5sh9Ju1apC!6M^vvST4v7Fj|OJ5~%8xigZmwm^|F#}t_+MVH5{MXd;s
z1zTrfy#z)f(5V2uI!p=?`Gry%0Kt{30aAR-bf)8wnE@f&Mn^&lKshDTo{r*&YAZiG
zo<I{TxF~JXC1RP-9r5Pn0V&(&rB!O$Y}FdKRfTImg{$B^Oay_i=sd*fKnO`<NrXcZ
zaRWI@Fz6e=Bf!#4#$_8Y9@83b8zekj_3RI04R(=S6+A|g#W*%J0XN3grgF%FOH({f
zm&D1JP!}w$i!M!qWN|Q&A8^fhGTOA^4HMF`I}#1EJ#Ck3!suEKs2@X=m8*ysOh2|j
zcU+r~2h5Uc_N67tHXrx-HE9M8j8eh3-+~dNaQ%kaQ<@(4z69YYSIG}t(Rc?M@Bl``
zl1apeS&mMGn$`fl!NZ6q=;ec%3B-L<B%EQw6F4<ahI%sl^kB6jrZ!wHSXUfvjn9cg
zZS{dKFhgQ1*x~AxRwURy#bc5i53LzunfGLqt7oqr_S~SNcC02hVTZs-4>b2uiqy{m
z;u)xFAJV~UXjq>FY+z<68mWASWNc+NcAuJtn+0NG8#qR^G0aK5f8r^m2l7oD{2H1T
z0pd{#UJyfgC1MIiQ(Q$0pDcAFMeBvB4em$qp;XywL;{CXxhp4x)XLl^Y3n4Qm*|+L
z1}$$y0!DAO0)e*^J#NnpDr(0{v)p!&W!M8!I&#f0`zB?F=bpSsDSNis{bDg23N?ce
zt%d`QMoQTVKRcw%93yQ+Qx?)df}ln&I|j(dxUeoFYLTVp5pvQc7+QqrH4;umHQ}xT
z8H_~S5BOw8x<M9SqJxHkjlkfB-|jFWHrs7^Vf0%mzh!LyY(U{=#;^90wC4tuwPR&Q
zuN_>{^*~E6l`#Fo^5Lgo%`|-%1vBv)6pvD_L5x!)PNs&M)-aHaXi9=?KDFf~Filrr
z0wa4y)JTLWIyk+fwsi8|$ZX!asn$o>*{fW1BkFVP1K#|tOm1Yc{nPIawFOiuXKE24
z!~%*<8G@Lft9N4fwt%WnafT3Bbf~N2Q!aVxCzp3~SU*1wv%$`9zUCCn7qKR;<XL2=
zon_^jMJ<2(Cmbigw7t_%LU=dP!-=_~sFb!~B+@oiqo$;nL#dilW@F2el4)!?jmbZ0
ztr8>U>L?RMXTs!As*KuT3dktq%raAlP-RHhl-a1Eq|Dlrz%4>4Ig~1aMl!gOPc|AM
zsOenQsDwO1(_zp68ab58HX;#gorEDfhd=C<!#$BuQ=|;!YS1PSNz-EDG)CO2tTodr
zz4=XTG?nA5?m#9=SAH5vQgYR~_-j)ZSldQ8hEMTp%8=J7-_~zaDiriAq%6Kcqe2)|
z$}J2Y#j_>Blzpa=Qa!~1NsJNFbjrQBD2KYX3prGX8Fy@(8@gt&O<@l8?wp_S_7=%A
zi7hs8Qa3OHPOeNfK+i5Awg+M2V^@YKr2u|thX|i_@0ge1FPEn+B64gnCvVL0$!*Wx
zf^7_51Jfp_klN?9ws5T{4J)$1!m>QRZF5@jQ`qkhq3X!;g5SCjSnR7ON|79W%wg)P
zrX&peTz)cF=w|3hyY}t4UMK2_kqG{uJV?37H91AI#ITP&Z4FhOf<5KTUsCUWz384>
zAEfo=>s?LmfAn@YE|KZq&7ga4dq|QEye5`<Vh%(EYM_#8$84ZNEsDJ3VO?nGExRP>
zyzuThwCu4(ZhoiHU1`XlM$nq~OKIkWZ&iNlVQp#Whj*u(BCd}7N-+2O8MNw!<qFpQ
z=e?-UxdSM-m^&E^n|ISpTKUW}m!BCy$?PZzc0#a<8fo~)NSf|TE8f0MF8%$o!BpH@
zKT6hC)Y1blE~huYT&MUA?p;WCj4Pp{{A?5--TL1pH0krT3f8GOm+n5lgnD%3vgNR0
za~=KYs_CS7P7LsT$>Z6lOFo_Vqn@<S(6%&d$tD_m*IY&4pt27k4#`&XpywkK2T?KV
zEr)e%`-3m9ptsoeAPjyH7<j&X!%kGlK9R6wbrqfR=h-SbxK|<Fe%?UWXSY4QlqP+l
zefFdMI?`!Jb)&Yea+E*ser_4P^ywO5W4}5^MA?!^=*LzmHR-QwPwU)5x@G7o)UBYs
zB3)LwhW@eiUHYPY4kf^<*3#dXy-#1PpQmvDx$`(`o7>72IkRF3T{h=mTrumZPpeLJ
z-M|y6U0#ve{cy|Tm+7-|UA_mlA4<RJegJjJFIKQSm%K(Ft()cYNjU;j{ARKWoGFVz
zOor$`8Mu4wy*qb0kEX)H0;;X8r7u7Gie7&1RhL5dEerw|k|bgy(JuGNPr@a`;N%K;
zH95ngQ(`B2GSQ%+1F2W<9;$$BJQmDbMDoMA@eL0sIe+OT=0FORG!#`dc1&Pz3*prl
z-iU3+y8o5Y*FXEz{Vje_KQvZPTIur0;WxKIe;lSd1a2lrhTXX<Rj;a|$wz-g8)t8z
zlHU)boYuSqn%&#~;=#1`!!r8fkPm3}+pB2c?}loa$$;bAc1d`~!cJRo^W7>c9x<*i
zl8uAT14=68&IkL^7qcqpj9X^YiPwBjOSwV3_-DQJ+cGn|;f(&YdR;Z0c<uKzZ+RtM
zdSY)XD%6ji8yVKBAe+v-eKs9)#WcG4$;C<um*=g_lj#)C6Esig_ZO}c1G^W}#>zUL
zht}_{F-+42+Ws2Eue}(*&O^`1Gb`w<+h)^A*UeCRUij0V%61d>bA~Nrzg*<Nq_RH4
z_4;(C#qZJw7r2^Te_B6UU0y@~$8_-7CG1c542{!y$M>L5zu!PV`os71!PIiP;3qv@
zf4U5u2+RVFx(0!k^rV;Uw#y5*xh?`59X~IhP2;9LNT*M|hZb*MP2>6<qecn@cHZ}o
z(5cfNU|1QA?{k!I6ycxC-lub>KcId$E_}|>rk*bCcPuUCj>oCfAEa+LE~bfnj-$ft
zJeHP4V|yJzAG6F~es>>DTJsHE)O(DAi7Bu%-7x9ZcND1}kx1lXPH$iY;u!8kEMBmf
zuDSerdgt|bY2W?#A&gEmN{Cy44HfP_J5pz)yV9xCMN*91eFXjZXU9>OZk-k0l0{4D
zrfcs|@nJg+p;ONKCADi;Of@w%^uPB%rT;ws936ht!Rq5*g{=w|-WAte!l#67q5nSd
zJbm)f=PIwds+#_M-JL3K{u#EjohNX@VTsi)F$Ww>@7ghdwJnBMo_{^ISzD^M(B}D@
zT>K6PcBah>Hd6J<DmQQ7Rl}%a`UWcO;|+Hf^eCkKE(J7;AEveIY6xkJ33fiZ8&&Z`
zG>gx^U;My)s@+gai}=m6^O4=C(-B?W5eqQizDmV)XJQ17u)R$Qrc;#_n&erouclD$
zW$SC{hJWb}09ZZoRw><hW`Dv+1m4g)7w6HnJi1iAv6i}Z;Nf@{e)#U~>7#Gg)8JmM
z=*mYI&_b>wSfKXtv<*rd#q;sSZn-}3HuL08#}Ix~pSgH5O}K9^&0bnb_gz?`IuaHW
z;%E6PPZqtFLgyKJ{^^M&uB?B*Q%cvL-k%1sp0ij_fx+!hFzg0~!7s1@VGY;mrKMHG
zpKEXfe58EFKK1!*xAwG>J7jr0z4!MwR#F9bq8@s61syW79UZhwJ9oq)V2;Z-P9%9J
z%6k^BuiZ?4U!ogd@P4^;GVR-82=y-LM2jj{E7+E7ZeF<2eR1_yv~T-C)H}Z;EvhP0
zs+8AmqSEU1ROftt9GM+*TT|b{&UDSZXQ`sLl6n<%P{&X2RXl*oYAUEOC!cwJNt?G+
z)3d9-pkq7lP9xj)bw@0qozH$HDc+w+ue_}g!9xwa*vK%w!S`2QULF<jNW|PZ^8o5V
z6~Cyqrj}+*n?<9KJ(9Y1??UD4%59X}e4c(a$gr8eKK&%siTM1JFKOzO@2GtTJ^a<S
zZ5uj&!r7`5F@Nqts^_uJLykC*zcO|Z7r=U2wX#%o9-vNH*&3Bzzg|CFke8d6%U`2A
z$Nly0+l$&3hw}`F9SnAEK;=uUfT~J4ICcz|!8RI6cd=z2&)>G$shCzg={;oIjx455
zhj*dbzn|{&mUJr6!RUA4AgbF`NA)#ZRA-}RO^w3M<;Dmh*O`Yd;I~l;iRC7c?eK~!
z>+ARieGt!E>6SaB9k>gIoq2j{*=An%P@oh*!+FkeJ!ms`Hfy-U(2Mi?cGIvQj_O2j
z-aLYyxq3ML?4Zu-J`CP%CQmR#C!#??1X$dW&Ke2P<$w|Gl<o7_b~msLh&hlOd*zp<
z9_*}Ry3y-5jiBeR8BY5QYokc8Rs><@631uNj?Z}g&|2<zAYfVp0qZXix^w3P!8HdF
zH=#hW{&<TmjnxS;`RraikgB)T&{Ce_kf6_+AljpCe}-|ViANeFoZoj0J-gdw^w;5I
zX?W}2D!WU8exqMpwVHm?buZdjS4EX|)zl@om@4XYnYYf-^`>>MzIM)SD=gEyI*)l-
zYzZbf1H$OvB=D`SuBK^Ir_-TF9L!%zJ(_;Q)A5*w#}{C??VuhoRuePck;uu(p;kPq
zkj-0PHdbt;=bwI=E}w9<dcN&{@F<nPeAx<mm4^`Ded|M|)DI5amnMHUg>Jg$4qCfL
z&#gXq_oFI3ZR+=~;@~-a=b`SebC*sO#nXeWWO;A0ypJ4t`&b`XT98w-T&XedBo}|%
ziKMgW4%YYhbssf-v5M!)5wJ*d2(O=5&K(PLgaR;hI@FaPls$gln`Tb@j<)c_Gp|D~
zZJe=zI~KK6!Xp_S59vaKt{tv$bKCR6J&tW}B@<?ESiW*r!k^^W={Bajm9(ZY`*x%U
zcs)aH9q~E=-Oypt;7<<dOn-cAA=U8fcRQZ8>g03|OZe^mcYmEvpG;d%V}IC#I`Fy!
zGmHe!eLS8fEUkDF^S#D2x_*I;`GcNE@6$o8gMjU3P_Vrnm^1o-QI?Azm`8U$yNrER
zPrv25kI>Gsza#tZ$NP7ptN*dc^%*))oA}<i^u%7Y|A=Dx-AS6JnEmOR<wi^m;>C}S
zvDnh&B=(mSb*G<pA4Lx=dfhj|0Nj#R-ROjF`_TPM-gIDD^snU~(S%u#(Jc#}ry8oI
z3;P_a*tT^#32k`+=Sf|EK({Y?jW+S<1J+Y4<_=1E%_cgn`@ytpn?7__&%+drbSzXN
z;*al~3Jabrwgd?4NzJJYK{r3@HT~P~DL+4-_StVQ>d>(Ree;!G?<Ke`@*1n|1lvb#
zssFCcfc15Cb^QJE4|uBL5cemGBD;0#swDL2*`3DmcjqM(7su;WVk+c@t8Ni8?sSwB
zrcn@VJUw~cSl*c~on2nAw-w8)F3%ki&ja0f-gfQBWrXPt1avI&JLFRZ4`+8cxHILn
z%BF(u1=MEOb|j+?!*1V&N?%(+8+l|Ri}!NZtkrK{vnGB^eRx6M&|5~(hVRO0OJyz9
zlvaDfcEk)11nR6LeN|g00P<xUT+)g5;}M2icu_3o?J@U{u&zS4sMnv~kKX=jts2tD
znuhX?byUvN9te-~RLB=ID(I`(8@VCwNTc^|PfxwOTEP_0b2QIq9i9r1?jP}omEL#@
zx5C3SF}iZ|+5PFmZ_DX9(bJIy8wB?3N7^sogsBdMsq;3`DxR{q@pPW{;7*nJ<vLy`
z@%EH;KA(Z*wcN2deM~pH`Zs-P#-dGB$)k5=<=U5uVJ81X_)9?D^4rt(Lw-q<O24A_
z*G%(C@0Qn&ZXEP;dTsUB^!{4B5NfJ7)=cH;gIb!qX*sRsDUKTl{gV0=cA^bD0)g<`
ze#g_xWm9M|PlFWj=fyYhGz!9>7QRUT*L7d|L;s)B<cfJJe;w1u3;5Kxd)B0#1UCe$
zh!Ke`TX+kn?g#sEd3vLuppZ`d)d}>$+aJ=Kuf0tJ2MwUp&OL<|&R<9~r_b`^Z?h?R
zdgwCEct-+$d*-PZ>Fqb(r~MBcMMsV~ly(|1jQS7k>y9=oUbuu_dTx^I;;Kq-9$hkX
zao%VkU@BzQO8t-#kc?m?@~q~Oiy;ba@xrCNqV_c*p{h!0h{PE#h$C`~n0ec0Je5Uv
z;-TWb+N&KF%XyAlLN32$ZQ%#rARfX+$S%mC)`N4Y|3xJ<`$|34fzHLe8)mBM3&1P+
zA&HVG|8y<?CM&vpekkwp>i)E8ZiPzk_!H9uaHLz+eF-ZAtP@C%<&k!2pGWsyG>E?E
zGP~xVi(CM9A|Mp<I+xp@UZ#fP^EtkR*99zJtM9?hRl2jGznWN2t(=_<*iLybPj#WO
zyw>39GEX%EgJOi_>jeByh|a9%Jr|THJ+J#G*Lg#Zf{ka`Vz$9pM`Ef0^o^Ce!`+A1
z3Qb$68%FHtxPx~mwdLsx_zVk95hnA(R{Rj)qkmsHl;*E+rg{w73L%9*Ak~X4<1=Z;
zYZ`7G`fK{Sd;vYO_-&swz;5CW#+3C7=waT?;d6|ExyhNb=$hA_=5Jo1Agy^s;)xX>
zQxUI;z!b)+8ohgOCU-op<53KR_PIs$=uYSOrb{9<SM{I$oR!$FfZwE7-oZuPCqU(<
zhU}O`14{Y>lcs+Cox0AOGha=~4;ngXJL*U%)15!{)F>T^tN(O4eeuaxw7Rs6DtLOM
zV?jPUx}Lt8{0$v_{1McvPfyyHhlEzIT1`9cGK^L%Uq!M51Jfa$I(MWq$DTrSX3e9I
zKm1JX(lFIF<9?od8$4HXZ}DA6UJsVHH<c=RLmhc@95#{F&lI&I9>W8@_)V&=qK3+y
zEq)+bbl*Jn6Y@PL?azxY*Sp(4tGQvRudbtPo&xE|3+Qkcm%Xlcd$i}_UErc~G3@SL
z)l|pY54<-!;km6}lh@J+4D}Fg91peT-2@L$;I%D0JpY#$S5QfhR!Y#avMO4+wuV-(
zui>HjdR{a~yiTIKdO*MP?^*$D002M$Nkl<Z^*Y+bjpsUEfO*oPU3oO3f)3*anE3F~
ztDmhU@O;SOd4GWCCLZO&^hXEYI$Fd#KCoYZAfGX^h8I3!ai=vzxJKhAMX<7ko)1hY
zQMNz$(n=~}J>cr)Wz}l8#Df=W*aI&zj296L3>~js2ezj7zA2}kJf(LbkKm!<`eyD%
zD&ut!KA#=y_>6H8)RtFXXMqzKZ#<))n(DwV4zmNJ5F7d@iAxHz^HnFJW=kDCx#A=0
z$qOS9uz(V~8veu`48WdP`LP4bqSe(KsC|AB4Q|zyzFa?tI_I^a(|C#kAGw;nc^P2=
z=c3J}RL!Fm7$5p+mwgoM%MJ4t@10ur<b|ANl$VuD7xNkmOm$4(xKzRL2mTFL8&Kfj
z%*}8tjf3e8J2y;k%;k1TukSmEp8xNQwA&uLsww-aUrkjqwy!_hubJ;iFkeg^$bv2G
zyuj4Pq6OSr=kUyvFVIi^?|9mCpWR%4PyN~(5_|sXSLm#9r&9Nx-PCX8iqgoA1a^dY
zJV&}bzh$0F7cFDhi!ARr+G8I-EUL=6Ot$j~)<~qXb0eD{?Cp7Ydij5rM0?Iy7L8ka
z)@9$(&JXQQdw+PaqMOfWMbz=|H$pFdShgLh7wgt>!!!MyDaPBiLfNkWL_QMrJ#O)j
zrovx6ckD;O8VT&&&~QI2m>R$hq?{pfAHSJPxSmI(-r=G7s~=lLcZ?m#=O*l|KzBa7
zRCOZ28^iQBpFM#7^M~PT5$5x}g?JV3+!@io$jb8uhvyl*ND=EMBs@G}FulTODcsKI
zEu<biUw{^CBxFR!#!F*sNPk}RD`!aDJ$|5ze&Z91l^p`R$AI0yFzog~=K((iEW*6w
znWd@|f%G-(7n~#U(ser_Nq6yC5$Jd!{OX9#v~$1KD!z$Fb0$7GUp1gAqk(_0M&dPI
zOBN?|=kp`v42j!^pXQR>Fz0DnQ?tQ^-8J-N7k1se=c&AI6J65pI5!UqG;dk>g6c#d
z^R|UA(anQ@O;7G}zQVa};j2{1I0!%NyeIA3Zjg$v;awbmnD=x-{Y8~G%Sa(Re^e&|
zpFX#YN*sOcVLU3~jH)mbJfhHPupKs4Q(H}Mz5Wgzbm#%}`|B@PqY>YIGmS7R-eN<T
z(_$KwnQv`a9$3Y^y%W18u&{DVoxTY~ClpSXuAL~07f+Uzu2Bbi2rTuh_JHujg3KUK
z7Dt^~o`$V$puE&IY^fCYJ$f6BJMEH;t8cBdoY|^h5moZrR(*}XLKXHcQad@Y9dvsP
zR)0B;@WcG6IKHxVB<|sIA8(YqzcegdL&Qop?mrCMW0WGe5E0yPz|_*R8s{z0!oML|
zqJ)))2b9>|kK9TZoN;MrV<dQroiE`D2=kYjj}e6)JQ{%pYsu<r*LL85t?M(M(lED&
zLJD?vVD}3~d_olkVhRB=?|S%Fy6~)tiVE@(Y$obF8${E1b&3zvRtpVyI7$MO@g`v2
z>e-4r0d-W$(-vx%guwaA<4n|*M>xuO#KGJi3Y0E+yeo*m)3K&@qd}1v4QhvPdq5s6
z%Hoa$pF8Ozy7T@U=%TS#x_PiapI@_cbM^ThK~D&MM;<+2TeenpI$YwG7704b(Eqwy
zuBNLdUTx&qqWtAkTXyU`^UeqmVLOa@GNlPdPcOLE!GtG|TP$aurGfPm^6HA4Rl_WF
z$%SpV7|GU1z?%_Oz~{H5o@Yjz7uXk0VZFrm9N^<<|3yPn^<D5R1>qi6)&dWcgZpn0
zA2=2k7B|-7*<^}Y6pFJ(LXm;DTQDLh%tKm`kRVmf(>*vpBN$vx5k5o5LsbYt4l+qG
zEo|gKD(OUovk?kA2Br>lXF`7gRL4D<8gA5AR<C0m{|lyY1OCeDa@F8Vo?OxKh!dnF
zJgGv(-0{IMHqxBpaMwsUXlSFVcwJWwpIVuho9lEa3~tVu5^Gj_+g(LMi@F*nrLT8G
z)<{T6r7t}V%0#OZbHFyJoE<9-1-2`aWYZc!F9)5o!|OqhG`}>;C|HhR2U1zf)0)`~
z?2M%sEcYV@J5i=3E+!(1)Xj0wG(f;6ZARlku^D16(;A6hX@CIqBBf`NlHTZKge`ZB
zuMceT0xO{O;ar~LsOJxBNoT^H)^L&08Ol;?G`8?=!RlIk6*Px;a%A(5VK57I2R8YI
zxE!{ph<|)1j^%J#lRFNjg`XD^b3`#yxkN0F!;V-o4`6B|)gT`CmsYA=cHo;H2=irF
zzDb)rp2!7L8?iznX)LlvM@p&}5aj27vS4Z>R#0!WCKphd&z@LZQb$T^Tk0%@;;x5z
zYd!PNga~P%g?B1fHG+YbI-~wHtYX%BGz5}#nPF-pF=!gS9kiZ16SY)XT|=8IxnogX
zt2!A<O`sX<6ZtgLoDAw5e`=!%?h(7Y{nq+ZLSZUr#}LdN*UWlghqp89&mgzP_pf>H
z1f{pYbOsz2$wC1Wn@MELKz<AKTBE6)#VxJv)OO`Tu6j0@tBii_=VWAwxag4)T|gcR
z^x`!WSTCW=Ev(yucWtb%;D5MP_|F#B2RlvB!6@KEsoVvbqGn6Dr9@ZHBMpkBJ|fW|
zaj6i)QqNj{O8BUfbrN<A!Q64ptOs^@JG1^wkDGUYq(`r*5}U;s+%h9NhM*Ks8e6AW
z{G*Ygp-F6Q5V4)N$I^@0F~f6XQ%VCXQys?h-Nrp^4TTLid7ec}bSAJ~B4n+GYJYh8
z!)%8j2b~IZB5L{YMeIuCs6RlI`SU}!Zc6mZuolrB3A3HfuwXkou@YAuBuCQv8dS`~
z_v7tIW!eMw^2oH59sJ;d<h2_2K?GLp!U{eKTcH0#-5^ddubzFOWFCr&d3fR7t~fXW
zwk<B{*{D@leS%=7&nmp{+v^v|!blZGLJRF<oJPVT&FxHtv2(P9LIE?-nW*7yNLZK|
z8N^VF_(-};0~=Aky(3|9TBdFC^Ak^dxrsS|1r@Vnd0ckH8tMV@uv{C;ZwGxm55V71
zAsJlJ25%QD!&sdBlxdLo8Duz>pbs+Smtk33i(P_^nN+0V%-ul-sO7M8yIf{F>&6|V
z(76pYnV_Z;GHI!mmvjVh#ze5Upv*BwCFGuRt{9c53mk7?l_8m?tIfE;8{-N&jV#OG
zkq{>}hA}aD+HDRhX2*&tqS>K|HFDkB3N{x#wzeO(mVEfXX#*blO)oVgHYTW@kdYBF
zaorO~dK?^|(kT=8s2evCd^887VV7h=<E-+KovhY5oe4|h9uN~F2`5H765s!*w{<4a
zO9~;~!uYjyweC3}F%${q6^k}iq!7JRWs?lw>qto9CZotWTw992ew(F+ieiG{$I7@m
zO~6pqOEx2-el~#?ei7S_cl~zlNM+aq&HDCBO}W_EE@HBV&-8UFxF%g7?#d42XCRp#
zYmdr{X=U6|33+7ubhKuwK8EgW_>jE>8uk!U4=G+uN(AhJKX6cDaBvmYO{flq@CBtY
zDk0epQ7w;1U}Pet5OiKj#7U6BTYgDUGX>7+RNU?AWXy2fwfTdR7yovgQg-%?xe6xf
zA;Six2pg+by@Kwd-|G168FLiRi&zFKryr)}32uvo@ptQw`O#5yA=?WB2ea)G7k@UD
zeRG`h6ZyCv!{v=1g2Yvtbrn45i9AUMZP)>`mu(!sU==w0d4YRBXkSZOV5mDNzcD`^
z&A8{O`*HBF5;s0qmC<M#Z-E8rKo8yU3zj?d5!v`A4(hH-^MgQi!K1dxVf@VlrORdd
zxuI;o>^$|%(7Lc+oOBor&obcPSaA7#y2Np1(`o!f_AQ4wGv}!zw8u?6m&vkd(9jZ+
z_#F1j(R{o%(kKYP&SyF%XF4t;hJg>#gBj-W)UXR28GxxcBhH!Sz%F&l7BD9+JSDB@
zQiLhnm<GDZ=hMgVG1)jOTYpkKi_X7P+X`KfH;&T?uy3q_k^1(;QO6%iV=rMC>pf@)
z`^CY-cPWl$*!dIAVqbE788VQ@^Ou<6KV={D9Dj-97pA*lf{xE-dB+^b<u`%lGfyAg
z?D;h2*uz~uv0<#snB$JnJXt<?Lk4~bxQ<c3BRN&i{8?v?&4E0o8$aP3PQeD~smodU
z<+vm1ybI1^81a`t`_t*?o~m@7KX(BgHu?}ZJ)pz_J5S>d0G$(`Kac5-VmhRmr=oM>
zE>D5k=p6Z0c`;znA9~}5@a~)MscY1qtiio^N!s7L|IyoN>}eCC_@o6xW%7q8Rf4#F
z%I2QRl=e{`itB^8y4=g>37l^nl^mD<4!ra|5VveJUO2W5lDzI<D48gDM7GZw8)F|r
zQzclD2I^uX$2k%g@)6l?@QLw1u}u1)Z*^Mx)8%DEg7^kVM@{Alz=mgd?7bMyk+|^e
zi9WY_P*Kav@nW7nHoNM%C$J?Ohf5h0YNP>g{*I@3SR!n>L>7OfON|JiN70bLvefiN
z!Y++0y61sgX#BbQcyLohmO8XbAB?4TkzmBaL~!EStXm;}oD!#CdTK&n8@7c(GtG*3
zL^h5!-wFZl_1}_EBFf<ntUz1AMpI<U+NVrlN(+x`zlXzjK$^}2QWn8$91V2!(0^_C
z;Sd{k3VDsjI0YS4W5kLyxi0=ER#1E}tu3<W0u~NQ#TO05&Ab+Nj+UJp35W?9o^ifu
z1}{6km`#qfJ-GURSTnJuzJ_ygdIXwFX)=R&e55uXR^{Kp0UXFPf1KO~gLtJ$OcQtd
zZzCy?FcoYCABNlf@?GuSNDLj}k_-j$c`D*FBzgxMiwC4UET9y#Qm-V*>p*gh6qQU9
zUA$zwGRq98X=9O)mynUVIcc#-izs#7nv_CzMz}(?kzy*=NrbJHz_<?nWh8jR1u@xa
zx$2`|ycjbqpaW6QXG&D_aoXBcu?+O)FN{OW&X0exWdrOKm-?Ro$ts3N)d11WgEWJt
z2&*XX2~P7ceuozDKual;rq{EXN{mn|421l|`_i5(bs`ZTkmeD>?1Xkvu%PznAlRoZ
z<l|mK!CcV_CoqSXu;>zi1fUSdxF(?wEes9NHaJKYT&P}MQ_COt%B39s3U$hTmKYW^
zSCmE{k<i6%79dK%QVOnzOk6j!Wk-^koQ8GcCEGO(b~{KK$pcb8jl@2IE#yUoWbi23
z%)-+2OcNWBuDEpRl#inxj}0gU@wi_%zc4>6Jz+K;I4axr+&6L6s02g`s$5l`Ur%JE
z6Z8ZXOBLR7jl&E!$j^cgTX524RW&{fk25JGm{v;OwsmdPj)Zof>BMA}!NhI(j^4Jc
zY5C>Rlop`u8>9RigQwpwAreBe{j|Xph{AqB+@?vVWrkx#(`cAkDW>=BoYVD)om*<T
zHrbXuwBOFZ)cA*CTV#ZxrjqY8Z?$~dWesl!Reh&Mc?zVWRMX%#N=E{{KDXzm?0|>2
z(@sPq)!C-09y_F@;sF%3{8FJy54R~QR=P48$qVVKld6Lg<RoN-a*U6uSy=I{nV}*R
z03erN0&uHkpf?a`11xsBqY^<q)kuK-<jEjvR2mxSwkZlLK1?h!O~HDJ8eS`b4u!Y2
zLrTQNw8=5?ByPiNUU?ba{+U=n;^ru$lQ}kuw)w)gO{<!(znfaKtyR8Su3fr4*Y26<
zJ5wHi;K-P%FjnGHCa^0R%xxgsWaKW~jfm;qlg$7HwR6+rTe<4@X&0Oj@$ei_93cr@
zyo`9{b}W_afNU7z2^-AQAn~;kHrDgHfqL~3EC-W!L}YEz2RWHOP`I|0m%Qj8D=W{b
zj>$AIwejM*X7k@IHC|>&%+x6aMP)-1sLQJ&sE#9`Lmt*j6crXwHrpL9#FZG2TPCoY
zbo-}rr0;11heSC=Q^;+a34@yx4_LP?1UZ~&Td*ZlHb~9Q6u;)kXN+?wRrEdF95qkW
zNy;nkJt>D$C33Ro2!9*Ylj+55c$vr(J)$K=W67aZsp=zKO}d~SDjgh=FbGV1Gj5>h
z>e#@opqe-SdQ#9*;UF$)wdCrP9Wx>QAMn6wmz7o3JP;!s<togOHiPJ8yP9~-FCMq6
zWYt{EH47#B;p0(Q8E&P_?3`@s)}t#Ga_=!&zzK3k9DRuU%gND)m4HrQhcg^M6K3Np
z-Y~B=ysedY44>?mYRGMuNBQ0CevE=8lat#vmkRq9QC1GT)igoM1=7rT(?}1K()jl4
z#?-XfjNA1pF3O=UT=xEFfyVV<cG{@iHibFVyK_EeCn<N)FnEpPZNfl@fYT}C2BCp{
zU6t*cQu2|CW4noO%64tf_An6hQW`s$HhK8t(vSrkFpY&1C{?h7{j8i+>zqPrpV!(7
zYZHKpo}xw6T~(A-NL})a2?srS0dM>K*={c*jhMsF;VZo4bjvgtI!zw)6=sfsYKo(_
z*4Pp%+#Lj!l(-NJPVfr7gTElo)=Q_o{Zki*{;SoG<A~&jo_yvns87FMbkD61()#iZ
zF2Q|#%3?4~|86GTciTh3?AU1xJ)JT3WZHH2on4xz{`o9@@Xr6-bTD%85eLxjd+q9G
zfBeB`v}x03l@7u_F<>r%6EQt!!jNzC<Zm3m+#B$VNxL=UxgGLox2N}|-1hlOjhZ!8
zwD8WkwEC456b0*eSQi>{%PtA3FS>gUEqiPc<#oxY5s&Oa1-*(CPVM??ntbR-l#DKc
zVG0?+vI(YBVATkys2%Y%GO>bn3b0_FU0K1zRpK6I`!>1s=)}QP+*&_M)>hQggD<V1
zH@{p*8aBuZJ8+j`y84v99wR6A@GC3n$#+YsQ*kccb^bu=(NWi@4V&xe$A9>q6y3>o
zx~JYNP2iV_3|Jiu$ZN;8KXhpccNVnm>)7^(UtU3Pe^st*e>ebpkYR6qwT=!LQA~fd
z+3@O0f(@Ox(|qSx&-Mzo{U=v{ujzi1X!~D5_kJq2+bjxNn3y)HTIUwhpNF1IT?^VP
z#O0N1=$}j9r7z0oQV_O`VgGPoySC{|*OdG$f%*LlU!%9mrc!Zk5&fRwgIf1cIHgtV
z>CEZ()5tdc>Ds|3CD7fs_)U6i&36g;$usZ{jWrjkhmpJQLT8<ON&?}FPrpKMz40FB
zJ9ide(Cw+@gQ_sSk;^ZgI40bMCvb>&M<$RpgN&3r61p;(RSH%lb3hP3+;Y6tckJAO
zM+XXh9SNaWFmI7W)fx6~B8|vNC!gSUA{H-PN*z13r{Z>PBRT!+ktgZtC!VL@-*6eV
zYE|gN1?(AyU1@=th{?PGc+jKC{9^LYRQ%N!-iXaAD>sYEKU+gf9$84W>uYGp%_C^w
z6+@_O(n^Ygt@~dYee<(VT{#_(>`Hyk8Az*{4q@1xBPp97)KgFTj4Bszrgr;uRQbv1
z6jBO*l9fpctQr~Bu4ypWmJZgbFhyVEatFP_4>AgLVsiLx`HNW<^zXMzY5k@;ZXo;6
zMJM#6x2KfzUU~|JeLkatPQPWgtHMFM7SpLmb>l{OoyxoMjDFOrAe+v*oja7Pt7(tH
z`mI;d-RjXD%pH<bnC_h^n$BgIW@OTfUY*ybdk*konmGnZzM8d>o_dFE-&jXivhCy9
z_IJNtPk?>Nuzxdb1H*pLunQUX&e!Gi#movi^ES^0bdF9L-HqOLY`EccZTs1Gvh8Kn
zwEG}!yP~_@pyLh+=-&A{L$<&4rsp*je$ZeCifnEY>GSeA^m^%6w7IUD&hB#*jqP^~
zo%!v(E^HFRHZkm6hK*y`=?t4uv6RmF{t?9qTSE6}(~r*Xdn8R>KUd{l*zY*PNXEG7
z57VmZ^)!?_6i{XQ#wB$2v<Ea@Ru1h^Jdn=meK<|tFi+*B`Uh)0aNedoX<vQWEB6Fm
zfg9)h?`F{TfBdtHw)>tV>DV70MPGgXwLVl!`OP8X%NG8q7p6E`@rbuRU&7|tfDo5^
z%ZQ}Zk&uNpo@sXDcinvi{rJS=s7trb3U$e%rF8Q(cdGcXorlmVXZ?a3>|$QoT1)?X
z|5N(!<InL&N)D!Dc__WmX`C;=W`f#_i$?pCkG@c})m#|2Tz8iz-id|r1UL$|@BVu!
z4iDe^cl!FvZ@Jf)MeRGZS9wE*52Dk~`L*g;R8>~di_gAB@4fjURdO7^Etapn0S`YL
zOmsQfu>E7U{b{xxp@1vdDQEwRhVL>|Ez;Rov5`kx9_EkZ4CD_Jd4Bnw;g?U@FVOQ;
zL(i8SJ;8IogZ8DLp7cZdo=0v<h73?XM~CU=t8WK5X?XSd*OTH1LQQEk&Awu~Bx&iR
z3soneXlNVSIDJDTZ1en0E?vh1JJaR`8>xC_73Fr!qt?UP(##3p5OC^i>uK!=s}=5+
zsx2x{2u(W43%lBG<1pOjl%IJ2HI8<#Js*6iipOxjOI*t?TVG2zKE8w#8umDMC~iEX
zKMn3xNHe+Pr(qg52wTWyEa3+`x1~j^s;IQQhC1+@{-9p1==WTQ7Ot!$+-e_l9YUz8
z*}{1S-APPWs_BGRL$2sV1xyTOw`M~v-TVY>*WoF){Tl8B403G0iDB}DL`Um-2R4iS
zV%l)o&pjKI?LAx3Rgbalt19_fLiA~f?U((ZM<+UjU;X7~!!tWkHn^F$zIHP`w&Wex
zRj-szrhPgLrd|b|Xi?>A1p_|pf7yZcVc3GIHQYfc*R_R#d$uc~=^GZ)x|)sLfoMg$
zw;MoL&3b}XRITNssq5+63jN|(&8JGPsMZ}O+y{HMJ%Xllr(|7?_v|qBi;AmG1l%Eo
z!_ik?GU~jMZ{t(V=R~Ynu3vNj-(}>^w35^7)`oTHcozpxab#EN?{VayhwXY!BqT2%
z!A!g+Q8<wx<2kS>R`5T>pm@0Qzdqw6)rt80<1cCIlxc3`+_tz4jpMJtp%XEG?m~5>
z=pj5+aOmiRX#Ki!TD7v&J;<Z1Y^_SKUti(smz$T%U!yzQ{q^qKlcIP=!HSF9x~plw
z{aQDGTej5G8kSqsx`@VKdXDNul&@Q_8u=4{`D4{+yUL^(fi7bm+ZQ;tV=CkjwjJS=
zbACm;@DvM%z?N`hpO=?M-FtRrzpS_VWdr*KdY&K9^Jj*hfTLr!``#ldKR=(AFI%Z>
zimQ4<7F%{av<ua9PkhsCulz)A7)*5>b}FV7PwIzr(SSCJq}vI-Y2VKdr9I!=pL+bN
zkFasCK{^*;L~xtR&&b}cqH!Np_?jq!hcEZK<jDPRUbQO^+@&4W@qILRnV#;`xzR8*
zo<n;V(X$_wDa5|c8k^%sb)q+TWb5gxhtbat>g1N6lw(Jx8^UzYeW>Y7S?R{(EVdLc
z1ZC{cBMY#7-crwY!NsUU5C(co|G<Xl#rCdxebMpzcB0pB96|rRY8ahxV5guckB&$5
zG8Gcmhe)x<5U^YE0IKGl5SYdgn}tkZOBIZnI(#t&vS+)2G->q|h1#v4ow^><X#_p9
z`(<?BPG`{(9d}9KhY^dtxWn;U+1Jb}y?<Iar}<-j)EWusrF4@>*i}>GZ`-zQsBgdC
z?sT}+O~6cQq;cvcra92gWHyM@;5D;SqPQjPNcby-xF(!sPEM{G@<)TXv0@WF|KFGC
zii@vN1p6O6N;Q;d&|Z7-O?vOGk5vAC2kt|YKbxXPE!M3mS9uTJ{isS$oBF*g3_OSL
zJk<Sl?$U{(ct*k6chn;fm7DR#!`*%(j5=U%r6)Q&(0$TNZz(7iS=xdWpA9B?`#H9+
zaBP3yvHb^ZJHpPp4p-MdUvq~VG5GEISJCvTGw4h9%b$5PNBr_I`vqzEMf60+<Vx1_
zbw^Ju^fUuHN0*Jiif*{_&vfnOH<_Twcsh$M!LWF*_SE%9J!#<`bEv+?f73+4dj6U_
z34D{4zPMcJmDdT2_lSyyw4oW}zgD9W{U!`nBNYnZ{0Y(_TgpVPCjPb_hs|+97+zvy
z8ipy})z^_Ft!d0Y9q0jGBf(qfeIW{V!oi(T?DYEQYZVRFM<A5+DxfR=x_~~Jwt>z&
zzK0sAPypx83Ea6*bYEyX6P8Ncv@W4Bjmc=&fvsuu-W}+#ybhw4r`}DTBN=uS!ya;A
zCd;4=V*9|JZ2RBXb{>s5_qZOa<KUy?&P66{7oO19U2Ms5Q-8q;UIk}hQFr=D_fhoF
zqSvV|u<l?G!+y%J2Lxv9+&H|$&fK}$LZ7XhrC7J)^$`ezi+a$NGasjq*Uq5v{f?!!
z*{xK*{5hOE7ohue-5kkE@2b`-Xe*B4T^nB0ACDcLY=<3ruzLCZ?0=J8BH6j&W;hXa
zd2qf2raAm4Uj{LewzakXXQ_?KpC={c&uxs9zGE$%JryLD%m|H#M)}=0KIB~s2fII6
z6xp>~7bU4j&u%o9zez8lEsqYwsk)d7x#6l?giJNAm_|Xc@r;tUc8z}c;Ef%NE^B${
zNkZo?dLDlMoCPXt&dj+)#~;CKH*~(>rE(Qry0h))1#HL20Xj+0Vd<h}iY?-`ym$*i
zN<bxyKb;&s=Q(=LW<8Ix=s9opd^Jx8QcS%xW@t5_h=$+48?AYJC9U}P5}&9j7!bSu
zq$jQYxQsAufl#|n+rN|_sOvsnL*?Aibp2sZ>dK7@7Gg>;>B4*^xZC>`{z-Nxn?ADR
zCwjRbk0RW1PJjAfYB@a{7$Jy)LDuo3I`X=K4Ltm-XRXVfdjG^*rGzyRU-GEd(cD29
z%^lRI-qTZCpgYc?t7f{!35j;v<X{Bl#<Tm;N8hgJk%cur6u@p`*oO>zj$vw8-6(<M
z_SLqF4dokkoqvL-La-*{t2q^_6Eb?w_Vl0k4ch~BKA|cRPxnN+Kn`3R!Kzz+d%AYW
zFL<rQ6#8I|9@zy4kaTrmlYB5R)J%`-vOB%EZaUTQr@0X->MGUs>E)l$_Z3TM=EkM;
zlWwDERQn<HX4yA<28E_OzRRBU?%MCDn!n14&wQsFbXh=C{k%!W2hxLKzXM0n_tR#o
z4ua23T2&9-A;#iMv}0IflFy$V*L@iur9)%O1IT1-Y9#mqH({O{jTN(YB>dADaYTy|
z8u!_!UZi*4cwf!YA35ew+G)g4>OZhAtzDz%kT6gG@^i1bjH@cE-MB<@bG>bql83LW
zm9F$|Cgex)#QF#Xn><VnpjU_n97F$KeDbB*uGxt@3z*J8=-#Wly7ubRQ(ZS0yGU?q
z83GoDE?wjeWg^dnZE|4i9NRH%5wv}?v+DyLnhrctA~s>oMsOG`$MB2j*&{+v=!1%z
zPDo|3CHUv_u<VF`>_rvdt*2SPo#qo61p^{RDsqeSX~pA<UAn5}+OKuISPh}Rj{Efd
zMw8830wtJq{#qy)+s3siZBy$6;I^1TvF-ET3rlFmqD^$|KfUq;izpc2yYVPSn^rmW
zw9!beSX%=SZE`x4c=JZN7v_7721Yo7bc!g&KS2}2)(HrnTty7*yL0?Ny&mLWe%m`U
z>~4n5;58A~2VkJbNCj+o###4+ycKJ-?VDjc+s%(CWqT{rcA@*w|11Q(7o<V)a>8O_
z(<F1TrHLHEs$Fhtx_;=d=<D(Y^tZ)tnG^)r4G!#)01S&POImeT+dE%h{f(w$8D&+@
zIvDOCAYkyKj{g;A<*KS!&tJ{L2uBy50+}>_ibepU7yvy}3TWx{qDym)L|isl0N<Kl
z0@2o)!EHZbKrnC?>T-28Ka;r^k(ZyVKTNKA6hY)*S`3x^U>f;mo*4(sq7Sk&5WG8+
znL(`U1jQVJql9Y;g=+ly<4wO)oru+?WmLh71`*I8PMNGLO|L#ZXy5(zrh$V7&~ZN*
zL;D{x%B8NT&~xh8midcQex^DgF3=K*;u!@4D=bz-IQ8sb(v{awq?_-#miF0iPnz<@
zRF#ho(0Lb~LC2pkMy0>_^ec76pR!W@=5gLdXDU5qYQlt_YrsU8o^1O*0ozfr(7`~s
zob~v{sVAzPAA644L*?O*%`aa&dJbnj&o%U%Z0PASXyix^&-L#5@4b0JBrk^JmG+p9
zz(UI$-eVsH6SaDt){p8cYSgHM<YAXa&Dv_}b!tDg4HWAmvUs6V=?lx9x=Pf`p<C|^
ziwo_xcMU!i>=wquveTxM+qy8D9-2_X(}VSN|BEZBq(>nQ>RCudyyGGa)|z4R<oE?|
z|E;L3qbalXa{@YGm&Q7NGe3#f*<h$2!~fVF@|sb`zhIc6o8!@?qkkBUJO`uv*@kVu
z_u_%d_J>|vK?B(KfowZ=o51$J7_fm1D{)}L`y{d5umQU?VEfNuJ8uI$;Q+^WWBLYu
zNp5?T=APB@u)O9;@C&o^RY#$QSA#ya;v?!&(1Cgubff}4dD4VE$*`Ub>*c^886AmZ
zc{HM|dIQbcv;sLwp|Y9{w4!n?{jlra+z~0FLptqD`Pq5&$-0?LqrG+<k4BX7ZjM=-
zmT}93_j|O=Odi!tDehr^#G=&Mj6V8s+RRhqGiS{4F$YJFs}JNR>bX6v<`?Lis#>0+
zf(>aK;PUiGY#PMT%+DomN_8YO`=F5Y4Z}jlWBGKvQ_lJ&FSKk&nA%vhU@>9$#xqa8
zpmf_~pOJLbafhojBg|2T7oL7q6%M8V4mjioR5Ex#q%BK$D&UzXU$pX!f`Q;a|9XzT
z`$iAP_2jpDZ0D@lP@xt#{+D-)V8mj?$eq;G2i9=l%m@ij{_`2aR#e!xKkK>c9wP)q
zPg!7?vUt|eb2QuDo6pM-+y8p+qpEWP9k8CFYxgd`?XNEyet|sr1&dR$t0hWLSE)22
zsjQJGDk)NDNMKZ9#AAEWu21Zve(m`|7zKk`+5F&b&)Ygnc@8-kX7k8KVV_pC=cEIu
z@A)OP@~OpCy+RLxf)3k3ZFE6C+j1IrZYsgVH{-%1xJJT;Be(;)7pik2+VY$AeHRR*
z2PX_tzfn82r7+mO3_~c$%cecJ!};dq#MSQC{$nxq;xj~^`ol0fV@!8?ffp67TBqMs
zT{=FiBGVz2H4^<`J8w<Kr~*bM?z^Z&{YDLMOD60thW&+M_yLBXY#7Y8TWq+FM|FDf
zAzV-LLd(-(J5TrdY!9LHd=XV*;aIXp!b*+iKz~PDG3dePN8k*J&IQGE+wjxq&YjOx
zzn$9lq3#Ckc81->F#G^RcOaj)ZywZs7)|2oieQs_+x!=)ghw479XX!P>T@Lhd)bGy
zmUnbOr$X+e9L(z~UUL>_s>Zj0CtW&o3#8XbDAQv7$>+uJ!-fy0Pe1-5X{RBKA^Hy3
ziCA653otX@kqDEDe0bAZ%27m-u&g1ycVTl(rimSh`yRcW#+^1Hz{sQtfH;Zs7_jzX
z`LY#(?T}oRco?U1*G_6$0dMx^`h-MI@p7VgM!~=xCs3l}f+>Yf8#lQEapGn7?p>*D
z^%|<;0uP304|v!nUQm}hV{HZ~+VJiU_zfKlEX)ap#M0r0nDy-D=!uG%sc<hJ0(Sms
zmt=}vN_<S8fv~V&5mhbOtfn_oVzf;l%R8*y7}Hl~+>Wht&3a_U0loXtTj_$+F7-ba
zI6sJ|IeCBM%JwLd$9i*TVp&<^JZNqD-u1|>bm5to@)J=*1t;ukT44G|;=!xnt2b#$
zgj`+QF}EWMgy8DzXryQ;(VY+9LKmGi(JD%4UB5^M3pS!k4Y3)Cgg6>Ze*V|-+6MXV
zMmCRXWH}uI!SBkaTCV01ieLk~h1W^=&bDMeS!(JdsD)A`)}MM_qjArJH`BPYL!Nb_
zR0ubWuVKxDX)N@_C%bGRn>%EBOin}5CgkSjP<~-Pw?)250vmZF<k|Ivpt#@K;58Cv
z0faM5RePLDxxRe8LFUQ9P`<p08wd@GM)8b-K`0i8E?uk_Ihsn~AdzKD6W@|eoK)kc
zE}lm`E)~3X1M4?Z3D9$ShV_K}RM$wPqH`3k%`cS;y$)U!?G9L?2jI_C?re9B1c;2n
zh~i_QB`VN>oF#ldi3%AO5XLTSjYJ$1qWlx2M}wTKGvV3};y_vW`Pr?p=lUtl6xK*Y
z(-_bQeSjtP&5cV2VEp{Yk^sr7=Y(2E$uPmkVN|w&DGotaDyTPkUP!{D9O;Lwl+KX|
z$`L!veAojUgUdK!UogNQwKe$ccoi?e%p<IWL+7IDg2=L25>E@G`;!V25ga8%_yIQ#
zeiW~54;JN-bYYqHQYr^hHB`3Lk|^67Dx;;+$MuN~Px9m%#|McAQh8M1WBYj+Ej#9R
zqME=AdApA-3XfEItSTa161MU{UaBE^C(0*W=^`Bft1QviN2WEyItg^8bnt8IPx(0m
zhBtZ%=#158V0z<KEHo8;g?a2N6N)J=4NBM3)6I4wfXGi}u|Mi~0e^KRe}0@7$72nJ
znz{)RHfq|ZQA(1yBay22!kwcf3%~T0O38v|j-1R}Vd|$#7sfB0d`xXLR*>2u*T#~w
zJ@eId$nIec)7~-T$idXcwi@i-@T|quM$jLUmaB&y9uwT)HJl;^2tQ(_nG*gfP+L*K
z2U8oiATp$3l(dU0k9^~5b}$6rysA!w8cpC9NB}Ow=vPln3#gF^2fv}63D|Y-Lw4H@
zl|rKy^;I2GqY{eBaEvNDKP#7>VX8B+xteNuSI5@rOh7kRBfp{%DeLynaQr9%aF&E9
zJi%$%*M?Zw5L$Q*^rp94nkO4-e@nBsG4&1erOr2@x*13|oF1wxDxAp<h-M`W!a^A}
z9RMnc+H#F2T^kc-QdmBCi_AE3P!=eaw93Tvy$FsYG=n%%en=)pO>e+*#RPv6J(rl{
zaYbhWJTyIDd7VQ;&Xn*tN5_J0*VtI|01K2cE(4^n#v@3Be7&JH@s?7=JReerBN6Iy
zDVL`@)T~XDPIW*Fzb#6yh(9TGB%&Cbu8P8o(4+-{n#w}RF+JOYTokHmQ~54bfffVM
zo=V?eVU);EvsMMk!bCKNk0Cn^c|s!BSgPSoxd|TJ(ut63P`6;i1bAYz<WPx!<QimV
zNyqU?92^U4l?7U;V+Nh4EjIJfAuvZV1ZK)Nc_AO2i8^;wgO_0P6h}ik6ItA1qeEf_
zQ>K}3#?gsD$H3GTaMp$wTqdrQ0DjUH9T3c;61BYkEgS15@|mIu>Lg3G1XvdBi5MM;
zpnFU?Ci5sflcr_H)3MG*W6Mj&Bj96tKOG)BXtq@k#H(c~)uDJSx0*vUs~&U1%@vEO
zAf<OVMs*^Bod)10HdltrMTHo;i`E8pWK{6w8bmhpMGX@N@PvHs1YoTM7F&AG)>tM#
z(`L!n{IZDm^AJx0DCXEF0X}IjRKzKn+>uDo(=@~a#X(sJqMM*2t#@Z6atz`Mje8Xm
z?nrFmsgC*@K98pmqZ3TIRXP;VSd?<LbR!WRiDaglOq1cd@>*PEYg-mwd@aYFTicH<
z!&B*(w&`Cp9<)1bAU%D_K?#kQj<T!qq-KtDn2*hd(v%jKZ{mc;@pyIwHg&rbR!;tW
zox;$64J)X&K%!$2Xpa3fiPnMw+d;8ALM^)FVT~Y<L@Ij@CMZCy8%(o(3*bk9OiXaX
zNJVf%eki#OfIM`zcvlBL`j*8b6WP2~G>Z>tYx)j__{OwS$3r?2AczXEE*VY~ee;KH
z+txLW|9AK>9Y1?s^J3}n38N9Nwx?DYP4md-=V{YFJ7b#;zuJ8o4vEb?Jw!(x_)S9G
zPKDGG&>=33v*ZV_F8|1O0g4Evj-z9%Ka~Orx+xc4ajrPO0f$WUXRs7HrY2NZBBr6H
zZ@>UkBkuHu;kRgA^w^ONUE8EPJKzCK=;v+=wGkP@Trd>nT^(6`NMaVB9-LFamh+ht
z*|0OFtp?i$M9uQ^*aSKfg5)9iV`5e^JU>-SOEs2t;d})m{`GqdP#YvH-%s82DY2&M
zCAS2L@w^iU%Z_8uH9Z52mQ<fi-J2?|yvR-xZ_2Y;(pnE`Ud5l<v-+>5wfVWJY_Q3Z
zhEwbb;)s2?>ZaZBfyxsK&vwa4e%0KyPqde?`y!i15wM;hoq+WQJm9bB^%RGUPb6K1
zU=@dT5;z<S3pwKkU_vT9Wl|xIZUd$_0M{5Aw<dzW$s<7rYzwVMXQEbpry~!GG1+yh
zJi`h#fk`GZq`b7YIh~5TU9H&)AW;a8yEcCqhPvptV_EqunmuE#f=PPFut6;zHkfU=
zknKb1z`kSHeo4oL&2i{1aQp;1#K9A=G0aoagNK!H{5%IXF96eY;%n$)@)W(&)iX#3
zevpA5g2Yvtb+^fbZYX!a!t@lKMV_R^FWU#*Joe{kRo3h>l5$5}`y~;E=c}$S8iuq<
zC$RHX{Q+zcjr;AnsvPju+M`*Xqz7?5lQ`%A8_#r*kLwst<A)$|IWAk(PtFHV<Vjj|
z0ZmiD2JwfI#$U$w3J38S(&A5vi!PFeo)QnjkPn;0)}uKtKQJD58T*s}&BfPse>j@X
zn|Llu&!Q661#xyC!{*WGA0Fw#pyyZz4|F(sdz`}M4^J`dd<O<y0F!iM!eGNZr~JlU
zdM@R#ZDaWg`EoQk?2{ix&(CEzd^>;Ue70{ioqg#!oYuCV<;3T)?MJZfk{-zRN!$hl
z4>%35Bbn#eOU_p5!9xeqIR*?o&u00+1y6|!Pf4R3#$Ad!kVUg*&Y@#}$j@u$3BAGd
zf=kX)@!7NH^HJD`yJ_SjjUR%JAHnpv2eRnmiTu3gfUhcp=fxApsq~PcgWR}=9nIx;
z9(NYBo+x+3XW<^>x-_0)2p%1`0c<;9=X2eHa=14o4xXrslD5KFMjfx8=s%z@ojv{x
z)stN?cL5zX`cOLkyi=4f29)%t)6doM`3iQ3n~s8k=CIL+s2}ux_s#cl2?^|E_Epx9
z-n&M2fIxj8pC{lyA{)fpPG}5kY&;Y55_3GSCKgL#j>Znl_jsijOLjzdl=kUKY{^vV
zc>`2t`K7|e#FaQ6p6bc#Fx6@8SN}_penSGpl#jT3M7AbV?0iU)AH0eZ!Tb!TO`9^w
z8V&88kMJ?kXL!d%i%B9=(poMkyrBJP{`Gtt^sz_Pu$ail)r)Jr>^djP6S|uo{xkjV
ztjiJ+oE*Qkp=e0~o-f2#S+qHukBH`xfE=!*{`Y$ALzjjl5;w1?&6w1v<<Sk~XJcf6
zkIs%8?s@P=8h_3e3LR@Lw%`k-{u?Hg75t)hZ8(cA1yS@vx;Be>I-27^E$5q`g4&=f
z${Am=#+O8Mc>M%E`QTQD264s_*?**~CSH@2OA=3;t`J^Q?IhhYuT5=5>hgrbRt8(w
z=c3ux)uOpbPuClGU~1ZQIfw^*^v1)?%|{jD1kzq@@={(b<oV+fiAe8i5_`Fg8pHEl
z8p%c#WHNVr=w(Uic{x$Bble0Q1YG@bosv9-WZ*~|h3(?F5f{1@BZ(C%mkTwRi&1>M
z*-HZ)ga^|ok!<Dz8Z}v>_LHV=I7T+I>ap<BzZFy*mMB*V6tH`RWWmkm2;!1<kung$
z{eaPldOj61n@`2W5!<==JUMqRV2f7?G9WC3MMOuUF-#88qKUIpuUd_vVCJ+iD{NzE
zDm*i%v2fh>ui-umhh)?%avRIl$2^UiV^iCf=aZB9M5a3vu}pvuV<CF>0$p4mBsJ3#
z_pUnTr9GaANxnZfA|*;hpd<tNoBGr`QdZuMPFdXGXJZtA7doQTfc76C#C4~@N^Q-=
zdIadHXnEmfb_$~s9z*u7+6wAPZ>amAm$$JL-0(}e6g?F!3SkEfe&|%-giLfO@WV$P
zvCBi1SOY|Q!V_a59SMt;infuoNYty*a+<<|%*p^aT^?R6(LGVHMC|xEnYAUp+~$oL
z?iI5f!m%1|osGBoXt%*3HK-rPMWlX3Y8A#XlBjWkneI%8wvnbf&wm?^&eH?)=J33U
zD>#XH4Qf_I_1M?2Cp>%_797(ZFsIlEv(AOlseB(_SZ`!-6zehY{;$UXbeF}zh-7U7
zp$`^ds#7nqg9DAI$}zE$$3defS>k8`9J54i{Gpld<iz2az#%RX<Dm>|d3Q%G@9xOX
zu2o+aHAg7aXkLbg^ei2TFpZNrD#7$-mC<sw4=azxb8pM_Rpa?2>_Guvp@dAIneoQd
zC^Niu{SrGOc?J!&Rn0~;-pV?tgB2;#DhC)&C=l<;F~b*<4@O=*b`u*%x!5>Cci0F8
z$A8r+yfsU{Nh{XCJ~Y(0n%}!n88$+bi5vGLBBggpU>rfi{1`4_tO&Xe2-w9@k581N
zmtvHR0w(#RrZ;%qMm;ykp}|oyOxIw(>fkuc0MlBAa&I_*g>0#-r|P;|s;P216nT0b
z1qNIYRJmqA5vL;&G+7JLe={J(WY@&;=Ba%uS^+nzd@|?IRJ6*R)Rw}@f9spRGUH8c
zjZL;K&(sTWuSWS(f|rmh1acL`;MMP@AT)M5nGHThDIxnPBNJfj|7k%OdYAl21_m&h
z+YHo{qryA!D$TN4-qGyMW>Z`1+3I#66bpem{6u&t`$PofK%P6~j|^s;h#AT>6rjf;
zFx1c7>#^`Mpl>Lp2f(O=j3TJq2*n)LJz`4?+@z}%2R|c@aP+_^MNM@b)$qYq+1#<p
z<wcpf|KHws09sO0f1lU4y|=x+?UlAmS!seaDZ4aLnkXRBks@8N@QETIpn?c?K&<E=
z5l}jaNSEH1?Y;N@`geXgb0(SGnYnZCyKi?<^4?66(@&C_WRlEW9aLanRpG@G@sI}+
zDW%h1=@C_%Khw^#DVf1p>@YNZN}F1QL7+>kv0{wQVqY<G|66$UX>4opC$7GVwNcuW
zd$wK*)aGMTamK_F<^tQn8Woo5t{i1SPRk5-=m9vMu7FefGzQKM?zLJ(Kjn(bNxRp$
zrX`laK@^t5ZU9OXj}>T=Z&DtzC?M%{`ZOJu)7p*!gbZ5LD^PLT*(@x4g`ZI`s1F`K
zn0sYwYcqGA_})U2x5+x>_cxl0y6Hk&v<{?Ip%kPfJbR+V$wsvY!#Xfa(Zpra%mWL|
z)?nEK1B>=-&g9oW$0wL?os`!<FKv(co0ZpEzFF0V0D3@$zsh|5eqL@{A$fSiG6}AY
z+zN?8qB$!EsWe=a(zn9L{;%e32eP%6fZLul?OLrcwO{jo+t9qk?pZk{R=N<X0z*K0
zqCoO=VTE8>v6hS4fY?1CE{>)UH9l=zf902<=G|C2m*_RDc<6A`zRp7PS{^<h;PM=9
z%SmZ+d2%62>&M!4V(<Vz<ggyuR7O9U!R7Jw*}S|Gil5Ld=cNkq%3|}Su;kLx${)FQ
zM~xm6N&$lw))2wO*@tpy<{=c?oOuN_jwm9fqcTt|^@kY>3@FO6IkOt&#J=E-5B|I6
z2iac#jCyWthVbkSq@&y{M();Nd7&j2p${5W1Qymwwi3zZjq(AnM--Er(~nZ+V*Yy|
zS{Ary<ZtWt&8=TItycRmKd*Fd?9w2uAEi<nz(SfZq1fEm&~sak@a2+~1fn`ncewT8
zkefPg)Hv|vL;1}Ed;w8lmIk!A3F@@{!ABk3ZoAOu=wV)A<h;iGFvy>T=FW)^#Nojm
z3~-TyEzu`;MwKl1Rfs(NKa@Yj<d;W#m7?R+w=dj5MAl(|(GTbSBeP*#znJC7^R-I-
zD3veP?3K_B1wJy!7g9G;*0Sl+_>>@X^MGY|*TVZin)oe`hQ=n^u%Uq(ct3@-SMkj3
zUqORT3En`$Z(=E&B}R?muag}#Y5(vrAJr&8$Ck6a03%C8n$OobJYaF~G?Vm8e`z#v
zxXRi}>NK>A{8F7qkcRU}OP+Q8x8<Qwy;GH3?G_WLo~Z$TUf~j3EWWrG7eL|e4+!&I
zblp2wP`^6vs$+_=u1f{=?T+p|KJ@E>Y3F!c|6Wz*3CZYU5*_aO0|rQ!qs)9V8H0u@
z?m#N}sKCK^cfgRK&U~RU-jZZ!E&JD}yKFau`{*$B4TP>;%Bd&gunz#6|8OV{bbZ-(
zT$s2|`$gBkC;QF?6PBqGATA<k87eFCC=(rc9n4>nL_Vo(l+VU(R9D%VdQ^3_pfDw!
zRQKv`EKrshGMVlAsOeB<G?B$l@eyUn_VC6_+0+@8gWRD<9GD9XAo#ddVgn6m;(UwP
zr@nAoGy@yvLkVrE5SqgVv~UB%2eX=aKS@haM*IdTr^Pz#H^pnEZ9KXN2Nj;_()ta3
z#O=-Q-+l*uigwv`$58JJ|9+WAM;pU@Qew+mon%!ucwx4K+N-@3HHFDe5mW%Gs&6&z
zaK{9y8PvsaHLq!;*A95jq|<P!qW2;FX!P~tXyr3YY04$<P_Iw-r7<^+S9BQ9xpf*X
zyn9ZV&zEq^!cAMgc&Np1-6?dgeuzLc!_5atZAEU{=TFV604D0ut&;Be+GwilDz}nV
z>ze5o4=$o7Ut2{z7?y+kyWk*y;_f}^oX-rPZk;Nqi66xuerW~W_P2#b^=J0(MW;^c
zPu+Ncf~TX~?^{TZytslsHNK9%amo-w<DTw*XbJuG>18e`npT^&ETY)FIb{c-rn|H6
zKf8P+)pfDH-|>&d^wevsse88y`o-m=BDi1uW0Apu|B&5!(Al3E$i9~w-yeBtCEa%a
zLQ_9S?$wLFJgHykJIdst!1t@Zl<WH)4=tv@{LAs(saWH#=QFZ0dsE1uLHu?_-LdmU
z)Ty!>MM6t9t)@TD`xpIZ)rY2h_Ug4AePPgk)TgG7JET^+ZPq{N`4y85ZQtrTI<9^%
z+PBv@dUMSTx^C)U4ct9Vs2fS&+U7WVe90U1^VyHnj<v(+>TOSONlg0onUBzu%ihj`
z1E97d#$XA9Is713Az!={IVi1Q76AY!?6$`)blO=b)7x*nOLyLOw}avG(uNX&N+$Bg
zOANjvK^VZmG*cdClxnqM1_s}qKv45hfBbO@1FOL6v^cm>g;h#97)VIQP;Q~q@9(&W
z?)~Ha^sQ^ZMx8r%%4@}zw>Ynf2?W_J2bET2f}jouKk~ri1?kx4mYt}aZ>sN{@G@<h
zyOFx@-Yeu!!-1%RpXx?_ds~?U4!Bl5zntDa_N7opuY>#1;Il{4@<$hkFq@Eam1iFd
zji$1deUxYG$+_0MX|*s87T!&jC?N)~wzo$MsCV3RUY)Xz{`BNhTDzfzuHsJq!ei^{
zpKq+@b=Cm)RDk17@WNvRhbNnJj~YPl&D==e{mmTu+`hf(w8Q$-eNQi^<*S=`fH9Ds
zdvgu_f;-XkjvGkl9nE=``TFGbbnZ>lLbvwbv5vktu^&D2`l^U$@FlK1aC0|sKB>QM
z{P=@U$ZLZUX;E1^aN}iUdi}%o^p}4wGroWQ<iW<yr{7p(d<X8&|6EFIxLm$@@({Y<
z=z0PUPj_E|@3S_D@B4`F|Hp%YrR@9JJh=MzTdV1(?E6=_EYJVkK;~OTuS{M?XZ~PX
zXxTnIsQME7{xp}18@#^3I0~P6>6?95>!Ut_|4H_}knqddkJ5W<=J5W=RyuL;0d&^z
zN%Wt$rWk!^4xPvy{F`*|f*0w8!Jne@haW+&t(s1oTAJwk?M|juP3vi8(>m_pF;^4~
zHM}wM!jVUq0f=HgST~=(^7b!G7WK7D-3U5+_#yP_>gh_78pCURejED}@Cj`E%BLG1
z`NvakHkwAc@rSK=iz53boiGS$I@QpLr+l7T(a|DkLy}zL+1O&p?bmG+iA#)t^%y{4
zxhV`tqJfx*t@Fx8ktjEOn}Vk=%q*eVoQb^@*k7SUBBuT4&mMO;{qU#P(!QVG+X$;4
zJkaDXx>9}s<-AMIq#yt42J`zJh|jt3bT+(<Hf?I4RV!EXjzln`F#rHS07*naR8krF
zxR&(o*GFXFN3S@1@swlf2drcK&O4a=wmXca>u&ir;kO}f{^bpH+=-tv@c-shQ12b;
z;=}hpmRWu!PeFIxww7jI^8sy~xq(_YwbIIe%TrPsP8E!}YFk?W{#t5W&KsM8(Av;y
zWI-N|p8NEnjkDHM<KhM-abo#=j0K>C{KI1ZXHvLH=n*)b+;#->=>3oDeI;)(Enm}2
z*Z+PV&05qzNMk_Jsk)p-59(y{-)G!x#;sh_Liaqi%;2^i)R}6l%Bc(g6!JUM)>9jA
zihuRJwMN&70X4MiHr=SIqKy9V*b>^n?da}*EHRxR1`Ul(tu$|OBh3wt-FK*^c}p5-
z*=qCKj}d#-ZQSNt*)>ez;wIX}N23=51_>BE;|`>}h!He)(<|8DoBlZ8_=hwG6!3i%
z`;PpLf0S}T`W_xoXt~r>l^NgPoVt!0`8Tv*<aUoR%<=th_I(}u{%f9XzyJU<F%9hd
z9B%u1?8&~*S=wL*AK*vrNev<=X>^ymF9cKS7-Z-XagyOrKEMMBII7NS3}IdX>ZO&F
zX-&%pTGPCVURgPfx>VLskIHT|w%Z^xQ}NK^S7~EQ1Kq#iC9`>NeBE#(<?0XrM3=pH
z7tP+d#N=I@0XS*!e)RU*Sv0?4xxwSq#EoQe!>aJuwZ|xWf9+f|API@`Ca~1S?!_!|
zJpA{RfdtDndnL@mk5zK=DaX_7S#xRanss53S!}c}TsYFc&py6nc~lg9=D!vmKA?@~
z3?iT`po3x9Y?%|VJOw$1j%D!RshRgxG&eQz+aLUC?i_}80;ck>nswqCh21|n!ASbV
z?mL_Oyg3U@e#GeEG-u{Kdg-}WcvD9s4+gfUz4zNARcjT$?+Tecd-pIE(7k7OlkeQ6
z6V=vrqjPz1QrEqXW=)^Xjii;ZOme^>`=-j=GRT+;N-?A`>J&jmq6*n;*<}Q;g>vY3
z%wXF6<pXHK6MNHu6NeaB8V&@tJJnII1N+jnZ@q8m<4$HUvV9#bzGq&DM)_cLFMj|F
zWHVl-p)DPqNNNjl@HkkKeYvz{=2t<J=#$`(gL>F!e0P45Y@^u=HiaFS*{i_#eYrCP
zZVuxbdA#`i+iU2AgZt3gNA;(x&ltut5zX`lKgF+JD-RR3ysUwMJqQT>c+Y?a+|RIl
zFnVxjdhodwd~?L!1Q`tAW~m1T2<G5BU=uU(n8gefuw3E~7$8&khag>O*lS#^@o(mW
z+$GshjT7HzFs`Aojh<!SPdvD<nVI<B=|jyx=+zI`(aN>3kbMq($Nmz80gms;V@YW&
z`~JYQ%fnU=IO+j6b=~)XSn9@J9iWQ~2e}(fwEz%12RagzogTY&A4@0mY{a=E4x`t3
z#$iR{T3X*M{&%gYF>1P2$_#U#s#=qux6uv|0DyQ6!@KmOgZu7Ccg#ud*t_w*j8E`D
z;t^i<NDGeHhD_SJ%uL|v+Etvi+0rnwAajo~PwFCN)aVg3Vb`7Lu3!IwNyG!!54B6E
zHRs0muH`~YmJXb6<56R4Fn~5o8Lrd5GB#E=mwHwsi?xg(7}0#ftRnVJwDM+(k`E+4
zcz3cHtqdDE)TrHY7nwD9@!9{F{LR<jPBW&@qU!2uTDw|C;v>0IiVb`1w<nLF%4y+(
z#q<bI&Hd}i=ZvUN?z4NbB1_6=i$5wh2_B{LbH#D_QnKa?*=$+WTW<1Q#&)C07raTU
zcs63#C1VH!fHYhgKY3yw#3CLb#LYCoV;uD-@t}ko?Xm}D9a&1kEe|)H)x)iy4qo}5
zMf1^Idpr_JZDD8XOGaJ~tQzA$N2O1^6GnBViF@><JN~|y%31^tJm_{B*^Lh7JrQ>@
z4wH_M^Wr;e_$j@DCh?vC3=;koEKf|Ezlk<Bw$k~>52QV~bH3<{^~SB*uDoA@Z-hEE
z`<eZEnGWsI|E!e30#l(I)<Fbfr3Ih;(_6n08#ztn4Tr^q@$CB{>>u_>@Pk?;>=@v%
zM?!JWzbn2U{>fg{zh^Z)_4-P~qrP8!Ts>i6a`_hq8F(H0?uKLb72ltDMV53>p3wn>
z<h8zB-lQ~swmT`H^T1#Yt|1QkDH`8>IDM-3_GUKXKPx_D3=swjt9j|-<iVe&akWF~
zw4nzXxDF^xCgy~VrI(C6lK!&b`Pi8T)p=m=ac0@$<&{%nq~wB71{$QCxJ~i{r#qMk
zH(RO_Hx8IF<&OhT>}Q>O3O)Vgv$S%#)SHliDL1(KU2GEEr71ei!ZC=zpI!s`W%1y~
z87x_P7RGfGXRj7h$p;dxe6z=It)p`vHD&}2sP9jkHg2N%a~Du2UQ@dA>Wj^r854Hj
ziTVxbYi#Y@rL(o!OT`)QlJx5@G6u4quUvcv9dh`m4Z5~YM!zoYR-J~U`JCN~9cWr5
zPf`o+oJFf&SV1$d=Zl=%Lf<0?QW|am4-l&OM!KFmm7e?cp^DDsRKruewL5l?6i46B
z)zhjMmQ!m3n(jxuurk(TA<ZF;Hm<ai=>6LT=ybrKg9h_P1lK_|A4p>$F}!~bU3<<j
zdV!y`|Nie45f6v-ucm9x87jDE1=pE38D4hcVBQn4jE=tI1N!DKX3;SR^r2n1mzk~W
ze>2Zaqkf(DTwr-)6Avtw@cw~DmW*Wy9Ea}Ni(dI~Ep6m=TYsPsF`$DpL)pJ;&l*b4
za~pnu{d3E97?;a+XAPt07<Yf*dl&Zo$}bKk?1?zy%J=CC_Wkn*^rbzvlY7=Rch6<-
zh_3q5(9ri~ygZ`yi1;w}{Z;n8iI+ySUQiFXp}YFq<2r26!Gm^2+Ht7dU-L%Dv);U&
zem>)2I%nizgpHI4Kb-bA_MwfwG4^=cz{?x!nl{D`4pa`}{d<q60X4m7#`+~RzHS&{
zMx$R%4;t24?(s@{c>i7LUn}0_876PUrUXH(<>i4*7Q?bKeDx9~4W|$^mR!!+%pq_`
zd(a{KQ*CWGnm%nN?X=4{s;;S_UOZbqY}BwE9tFhLNjy|}+7s&l0)uJeV+LWEbckKn
zFuaUR7)$_NnL&QRBriYzDvjN4G#&fJqs)NfowsDl`oKy1oBV=#3+ek;-%OwT{E>9P
z!TUtyW8DRzSD&7=agI!pH8)EqRb4Gly}f$(40%?qkP-RZ+4Je4zdaJdH*LZ#XY+=l
zn}y4Ww9}xyY{a27T!gU5Od*>s8y8AlwXB!=YvWz`nEI;V9r<avvP%AJEU*2J{LXg9
z%5q*e?=q&6hF-*Lpr^^yW$ms#sIsn_7X4vfk)C|C*xcseTkhigP9L-`-p?ns7ncX=
z$9b(B0|fbll=RStUt#>=MI&hnU$5W)ZM2Sj9Hz!$<oHotj8JS8#O?g`sq4+Mz|Pxr
zrDxw;LoZH|14MXr^p96<Lo*g_3U7)#@l!tD==ke1&f5w`V$#X=GN94x%t1Ytcf(<{
z)cde)Kl<uO`jCCU{&$}5jJr9&UH7}Wrf#5e$C2{7<kPROHn6vNp9q$Gc4gmR;{6h@
z@#a+=2=M*)-x^D^7TSG5>iYxFEH{HV$9%(6>`6CU!bS`rFgSCA=m9KO<14GD(K(FS
zzHTTzv+P}(vTgxgKlNV2j@LtfvGaMfVABduqAQ)KOL;YIYHgxRM;&DlU4uOrC)9t6
zZkYZzqjhAL0o0e@1bJ-wn^ESNT)d^0u!0HjMnW4u^gfbjkA!mJiM>mgE<CH&LZ_a2
zq5)S`Rnefq_4HZp&u+c$b|uY;-BQz%RhZ^;m|Q>-kqQZDQEz65#4{491@6k`G+H($
z0Ad5{C}Uh(%pOM2cgR5E^;h1c6Hhyyh7KQMY{GsBgyl=+X{2knuDmZ|PuhFmJq+AE
zfu?(pI{L~*XV7~*0D1e3_vrn1WVr<UAkMz<G{Oc>4R5^q7EL_zAR07eAnm@_ZnSjC
zGTMIpwzPQRVxAe9u4G$xj0S>=;wY)DSO>CES^CYB!dn_mD;uf)%fo2(e^yZMiT%xM
zLQ5W4NR8Y9xVSz6ZfSs<cl(Uc$ekbEn>Ssqp{e}(r-U-9KXoXztZSk*Jca#H52(E@
z8C1W-(kUuT?ZT}Dvk+NASAM#_^^y^MV{M~fKd_ia)XRGK!exzSli-g7+%F$kL__Lj
z&3r!NUY@evEK3}JP#?Pa{}#}J6T0(;yfX9JD6WCsdE@Ssc^j#k2b$NOIm|3|yc}#w
zgk2}_tHJ9wwa^<p07(w%K7?4k=t6*8i^*~Y1K)q5zVnjJh=GCcykQtmceh<K(v-_D
z`IT42EnpmM=5Ygkk$u1A-UamOU3wVb|H-e7BJ93xH}-uK)v)j1J!7cx{gn^an%M@_
z3uZ6Y^DNCf(>7$RC9yZ{j3U4xPq0FXyi+6wulYfpd()V%1L?Ju)2X_=l8zfBo9pLn
zSZbKJ?KYU^Y+6Ru{0)W+_zes!b$qZ^23pwTfbUOq<{1Zk-Lbw?FIwHaf&Q`NRr)(0
z8g3bP8ck*%y#A@-i2k3T<&A4-+Im^yRJd<zXe<yh!T7-^^Yi5iG%;*k9%c0R`=6lu
z?|X;~Oc-zY(bY6-=3M&qPwwK`p@fdu6Q<>;U^gFYPApKlCC1Ey4k8RB15ZQ(H(D$&
zB?c^el<|XNjNA?xNHp>;&iQi}(vV?;cxPubefa)VW7{h)y-o)oc7R##`25L7(;D6*
zQC%bNA*=C!{@q{c3tv8thVveaz4!kl8(v25z5M}UmIM19@TSK4b?XU(5j^o?6X$*R
zJV>8C{s_WyiH3LHd{2`fiCC)-aZEjJ5g)KeqL4Q?rd{zKZF~DpG~v-tQ5(-PEdKLc
zYT`ize9Fb~o(SH}FG0QLIJh|V7FJ$UZeAl@{Fms{-WDm4B9+3sQUoi<rjq1>La5>g
z3rT!{W7FLee6!3FhH~dw8+=3JhZl|rS@5>Tl2uLN_a$z=aAb(P?)P))={Hx?Z}>Id
z6F%LC?*HC)=860ne&zA~*)p?*PIiak^5njup@lB{+03wM)bJZ06L>Gq1N?e$e8^Tl
zIlO$~VUGmfS}`Gym|+7th2M$z(FNA`8~-q0d=I`aamxkP_ZxUt4Zi>OvBh*eFXh~K
zjrfk&JwM=C4XFGAZ#>?9xXjqV_pkqaw)uz=aPWQSv0dpQUgm30(0dGGbUujjK`MV1
z67Xm-NUjsl9-K975><?lj&oVV8v5Owf6~ki@@n?s{dc3?dW|tAu54UK-<|yDKnu~4
z19qdM2lBl=2tOHrCch^70{v<JvkH<}jSQew{0iniy|$-6FL*8oAGI-H@c09$jTjH>
z%Xn0G=#d9fzBf0NQ8py<FN2z;70kRUrZjP^F95QhBvq(EU4AOo3NwaC97wPMC@kLl
z6!%39{;iE2lWYs^DfMq{;7tnzyf&jDw(t}g#Mt-H(9l4Q{I-W5P`Q2j^)^#8nAOnb
z5TC9i^Km{zVK!$|+>nvcS_smbRePg(o3kmUEM5E)ex3G$Q!g!8VCP|7sDYoT+Vs<C
zMuK?U$>26Jt|Kik*yNHhxOG|*fu0a6Uj_$21Ez<~TfD*$Ck4MIZn*14y5iKYMaY##
zx*Tb)fLXYkR%k>-ZYFT3zE3qR<R^9ihCGPj&D>5FuWZWYO@-K!iX%(H0)F$IH_^qX
zT^@FxhL%s3Ct9{~@)ahf;GPv@%W5F|xXAHc^$cb>W|5Z$zAM~HC@uwS>>;%&783pF
zj+^L`(=X2v?CO@ZoGbXo)stWM1pkVrwN4p{jy}9!qJ=x#l{_1vIw0I_Lz2fiPjCgK
zkh-?|WN|pa@Z$In@4S(|de+xX+UJYQxAI#bt^6Atc$h^%tH2(WYVK`)JsC}xLK9&|
zrk+CnFrgS81hO)ng+Sb%fL{ac)TvWsdE<tgucj+5zS@fApCp&pXDtY+4w;dNs>sc`
z0|;RKg3sj;$l5jXmPZ^O6}ohB*7edj37Zd=>Mz;?2vXaGC9tW|+wVV}_!?9<VjK9I
zAi-0mb;MF`n!Ul2euPp{A2*-ju3qiJ0Mi4vttd@lw#79w^F09;0~~JpSTC2f$X2-I
zia5IlGy4Kw>aYPwu?kBdn>##)Zz=de%n6{JNqlPa8B_9*$*y7v2p-!*HcT#B))c~0
zq~t|KOlN9zHd>!PbN>AyQZuj>0Uy>{&I5?J02(YosD9-M+>Wp)&H$Ampm1@Lwh)_&
zhzm1?;L+wQd1j(1?i&iBM4Kq*Y5rDxI$LKY*i)E}!9+g2{(#v^4N_hi<lq?q67y;&
zrwZ9n87E6&GSi~Dgcv`3#`{YAS&1z&kZ?`RSLiP7e{I@tIGjhh_+aaQGRD%hKb2)!
z!`7coMJ-pj#_hMOBP481*15LmKmjluxz9VcG+aIlO-{M3NIDm}89vNY`@jj_Jwq0>
zxSW7Fp->|nR!OGF&Y=Y$o5E~VMEI&_Dy=(+2uuY%f9okV7#gKuJ|#ztu18`{7vjDO
zQMpd+ia}Zj5DrOB@-g;3Ur?1vG58giC@WuKB{D`4@XOZ~2a9sW=P;1aMfRqo4Tl~p
zeuJZxzv`*861axqLf(Nx98(?`uG9uTn#`~;4{=5`1`@d?>M=8o*>uSt^>S|mvcToh
zZjNjQlQ)MMCDY+IXb6tNqB&I@4^^y<qjb@nr7CR-OB;TGW<4y<w?`>_xaHWKDc72$
z^yak3*9Ds}K+xCt@WuqDNNf1e*DHZb8$|dr{XA~4df<kK^;8^qn!yK~B##b<r?~IB
zi6I)?I&{;(`+4O_i@~Eu8l8_*9zXW!ipxVP0+u$?g5S{_K0YbGQ*Z%{F<S6}VBD{9
z<264f#+_<8<8k=1)9f%fmFvcgFj+pizc7l;ovv*v8+Jo44lHdLyBMan;R!ozmuxG3
z1Pxz@#OsqdK##-731W_-L3L{!#TK1|PB%cj4|DNp>F@K>20|4-ZC7UO`7tZOy()8w
zR_NCO8?GaBFi_nNVTxmn(ChUVjd5+p9gSRBn|J_I%0UF1#1m~iNHBv5<Wd69O33#n
zEX@{~ktnvZt=az@DU=f$VZM-+E}xtvd~$syW0GWbG<@r`NIX`%<k>Us=Bt?EOUQ34
znwNP7k!xYme6m*Ifc>tVL~d1(BrsENsil=9Bs)Bdq%1U|F`)E)L|%m;cJas?m<$*+
z3wcPFGC(c*Kvi#bi6(PaWT4o$0Rsp(BvzLz2Q0{I><TDxTGgtRzFNiSQyWKzjvk?c
zpSD}Mvuw@KsYYid<ohNVS`-`N>~dx4S1K_8DQVyW)iTX1*NlYuv4$I)&c<x^fkb9w
z^Lq1NNT7w2sf`pwTy$ZnmRteJm|WV@Lbjad{C=oyIxIlmJs<%%rOPidnL?Y1-@z+9
znR5$bvKVK2ui{FmP_8ukG+a&zvR|P0-GeJ`eHSD%M@fDF<Xas!rJT7C#YmhFAEgd*
z>a@nOMEQYn>^>|v??ZCyz}1{fZOaR@atIiVmE-p~crekHXD}g8@pyv+SD{>qaXMTZ
zib+GJ4kG;Py%>49JY4g6e2wt%OiUT3(ai6bY{t!&MK#cf<sWBIhDnVy4OeK%CD)Z|
zNv0@Nmrvhul6_6Z=Y1P>SfFs7?3BD>i_>T8J9?8+xW<sK`u%j8X7IQ&a%uBZ<np9J
z)XEgCic-=9ae2@QT!n)R(c{u0?dA*DTo}jZ)K!>eQEIJTKs9Y+O~v7&a$NpgOftkT
zC)KDiIPtWN!9)u-7p8QuW{`+Zm1!`Tz)XQVa7?x$8wNI+0SX(9AKh|o%qAfl6<o};
ztfAt-z<Wt#R)Uv<6yA}sUvV9&YwMMbCJ-%&XfEDz&?GmWWK6uYbZELgiq$w>R#t3j
zrDf9!omz6m=ocQ@U5~UJ?He$-mgB~OX;#>%2k>z=$Jrl&MKX>M2rMwDD77OyJ2;gK
zG4d`9lH5Gf90JlHC$JKpeYt+V7*&u_3OU8-Rvs;3%@-1DEx9~}`s2!oO9Q4))sl9#
z*_IN8mM#aKS$rzzfk7GXnP{%iM}v49%w7rpC|3*rM7ry5Jau7Eb1&d&EuAeXj5|AZ
zQG*{0CMtNp1ea5X4<xcwSax?m`jm;~;UbXE)FPEhh%>V}#i$Y-P|1^<Lr0v^X?oLe
zzAPShn;Q>!a3EibfLb$88zz>`SyGd6l`lFoYjz1^!~yMtU6`A;oxDJCMi73bRH)!`
z&x!|ERI_6A_6}?ai)3=8777XF=3$JdiyEUeew;^iNzhSCq9WBE7wXa@ji7Xz2P{h(
zbZ$^NF3e9`xjKZ1>hkHgmV6n1FQSrPP{=o!Fk7K{W&%G1hVqEpClOapaWM70nUNSk
zblg0IY6@Zu3<?TNkAEIabm%~$P_qj1VJjkz^D`Hg3yHX3uQYpw2L#}B(Gfl`qgvAF
zmBwRrvMz<2c1SWLi|0%i-f?pM0RyU{{o151<Ob@_G-$1+)s-}cbPAMKj+OaY(hE5U
zs~R+Rby`>sTLb{3K&x>C8D<K;pM{*siF_8ic%(J&KB>9zWKA7|aZAii``UnWgPWJO
zClG~etUP#2AT4OQfJV~zqJXB;I28x3sE%BS(v~(>+ck!CH?5t&d(9g>mO1$2dU!1~
zY0m_f1<H9=qP3+lc&o*gT$mpyohI{E#@0NDP@mXOE|-elb^WhaP*QyOXD5<-pwKS5
z;#{+)GIjEFgVX%jZAV9NhcWMkOpA4<F^tnR`2HJkD3`AWWdZ**J&pZ4G{A}PqZs!U
zBuQ|G(D|H4OCG)LD3b<mI`d8XY&;HphcWJgfNu=*K_-Oe>a(_JS*vYoXB;1B4rLuU
z5HxM_Y@g_}K4@NTQUBCV<bi|Dii0f8XT_mhl+P_Qq~Uv9nWf>-hG$Hk!7?Y(d2AcL
z(g$14z2Y2`p2@gF*v_*#54%S(PSfB!__GIxc^5a`!C?dZ2<H0=%fJrsDQxFNmU$lM
zv-==*JBjT)-`G-S+6!dB2b2qB!fxczmY@$t0|y_F2M%_+IF}Fn$fFz)5bFV1(2dxZ
zwdAGkX2ppQkdujz3kkoMGl@UdZuE0L<jaGb&V2a9yD77P&y*RbfrCusF}s9#BIj`+
zAU-5G(7Bj;=XfUnsxdwveiq7t!$>YqP0#3H95<zizUhHJ*oKY=?M%~C*}sF?{&N_I
z!2|3>y@L)o_=oyNBaHLimWAL!hcZ(>bhKeRV=1s@B9{yF!A`U@O#^ob<4n5?aHg#?
zCF&M3wO$|-Y3TFo9oMGTrC+y-LtV~bnW%TjL4Ir?6R)t&;%gIa8v21VZJudi1A^8$
z>_xq+52$zeci!b^F&E#@wi!uZz3fbro;qbF9mb#6HhFH>=>LqJOqh0`@NuXk)E|U?
z@ZmILi|JEYA7oy9#d${G6!!0kqb7#=lHoo(iO#=>ePaD*pZ8@tc+&pnVD<FmWB)>w
z61YWl#3!;**#8S5&Ce*#<}{_TmXn{yMehbT@1`wHJk;XjQmWPERT$B&cm06Adg^6y
zj1idSh=5Zw#qgvGOhAerdB#9m50C>|tQ}HfGRvT)hgc8DM^15)chAtAj1^0j9(1|3
zy0&XtW5dar=<9p@^ay~XR+Aco58siv_*D5+vI{pdOL>YI+djd*D9y*mwk#D7?MUN$
z0#}|E{XBU4EX&WWWvsDsXzOv|Nonx7IF(UIte*#u<MGQ0Gy-$aahy?@Yoq!XrLZ|y
zC!jWO>rbhp?OdVpF*-}0WH3R~_$<6%@2;&NM!ty|n(@IZFvbLYI=hm;ZC>RwGi?mW
zNHB1SW0`F%x`Fxgl}(K5c7ZA?E2uL*kIl;zZpisWwu^MqC12WzFJ4FE$I1L9z=eo%
zGz~0hePN#AZrTcqhg!U!0zCp0XxacWpR#ggrOT{1hA^r_ZZv@5z|#d%Q5plxe3ELA
z%NuDt=^+HwlW^hZ)9B+>n#i{2B5jWmSH{yMaW^Sg5<_mvEDmmMD<b8)ohCw+Gml}@
ze86L1fjmTdxb+>N+g1N*CKiKJHxQ#fB({<iZy`37hO<=pQz}QxCqG9}2TUkD?pe6=
z$x?hSXH>h=xlrx=U07OL{qt#DIp#VJl<`&wa}gLm0}CW@q_P06;0>5934;mq>1=*2
zvI(D&Rwmy7KhHw(wa7C5K{gCT_}?n@X*(<rBZ?PZ@_|J0ru^@6CJb(EfuMpjHOj1n
zZi{i#R%KEuD|J@7Bt2<xUpBf~!0b_E$LlCXaqA7<y{@$r_HAg_RT%2cl^UYFgiGnB
zU9$F<f=Gk>OwG?#o|blnxyCzi7pylpz}y2WOx-(t1{PrkWa|nr7Y8=cX*!FAo|{=%
za%hT?p~b0XFQsl<yoKkeD;S{mxt+Z$B*dGNvx8!VgVs%lc^Ih(bqGi&m^UMoPH7#y
zNwQ(kTERDkq`^cRzIJJ5{*r_^LRnvVWjU4e4`%UicvDj&hBF!X91*2RN|7WKOa=ud
z9Y_>!Mg~i_B9dbL%;C!cM4bfMG^v8xl?qK_QhZcbzFZcrEHwG_#Nl1JrsH5Dz;Ix#
zv%NtF3@9;o&|u}-vb5T43UoGSX>rRbHh@zl6(=R&@|jtvFI)Ab*{Wi)(5A`B!36?U
zz8fQL4xU9(cn*II!0m)ENLQOxhM$iS(IFt{Mf-Ah;j1la3bW9p@w+%JgCrPc??5AT
zQtmeIa<wn5KIOz*c`nRN=W0}JE=D274{=7FQk0DYF=#hRYLPK1(DAeZe}*ddI}_NC
zB!h{T^jQg3R$f(M1`%aEh`^7a>6ap7w00~gljF%Ilx!f;PCJq<+zK%8O`B{MKch6!
zT*Ms+b<vtvWdT~VAdO2$WQG}+T7j-Ih2@X)apl9uX~@qLy@`Qd2N7}dvcRP5<VF=Y
zV9>J7m6hMxXw8TOpG!3R&}41-DWkkDJ)W8(jZ3p2GM_=t_12&Qk#5@6;_3k0m7+Ko
z1{#GUtpTv;Ayjd+%2Q124l2|x9b9N0a!ak(wbdOws7{Sty0~;!I-l3|2WibqoI5a6
zJbqil4bhy7Nl&|WYdSu*0|!VnO%t&a!vIZ#AWsNqcU>Mgorgak+7*TGCsgo$h8FBA
z2o;M2Y_6`r%!FB|5EyvF^5lU-MKzZ;&qiS2p%kIt0c7(<YC~}vOEQpXp9#eozPY&6
zH;qf7*Oe8f-Bt#m+hP-x<|k9>uJ8n531F2Fhfc$}^!e$cg9h+|NBDAYdamrGv=pD*
zq>$F)^y4J{!r@uHEL^hB;c9ZzKAkB*b=X6qRHL_WkASm~oxmOv$LUv?8zXJ=lG1!A
ztOFD3N7QHes8~m+g+4iK8&o}Ni{|5EpC+!X6c&vor!dHN)2=SSeLad-xF0Ltjg#an
zjmkh?(-Pa-h{6NTe1aJtk~jj;F-zZ!R*pXj&}ROe-dfoLlENY|^AZLI6Ro_*p$+>c
zf&d!;tAH*(RF7f7Afko`5&WSmJBVOLAPv1r*?h5<QL!3JGLR@%`PR(W-hvh1GD^`_
zrUl~VAw@xMTFLXr8SMxJ<)hArhnQp<dtrmdJ&;T03yjMX$*m%|CYe^tEf3pA2A#cp
zn9_IN&j(&ZrlNfLE-tQ+TzX9-)}s`48mHHXsr`WKZCha`hCxVhY;5B+;xITF+{?p<
z#E>9c0xEFm@&(dv@bfNC)5bo{aIB`;SW_0~kf$bH{g^4ypk>x<oM#_EXw@j0i3M!0
z)i_dRb@jPIfS0Ae1PT@4GC66~k6K`2lLvt?0;Vac5n#~Kv!~qon?K`ZRDYZ=j@q20
z*$TnZ%6W68nR((tf@(%1YDK=q(ZNQwRk9`gmPB0ms4i`^`}I$$thgfiXu{g-Pn17C
z=R(a5%V}p)YM_V$-JF{Sy`L8u#hqQ-d<khd(8lA#%gW$EBZr0idWy|UIoQ&$DJwA!
z25cNW4rV1~PnAMWT-my?Xxh!i*a<WnC3d-Iq0M41MA$?0$vH+}i9xVWJ3dK^f*iZm
zpa6ku&HQ9{QcGpL>046lHP>ql9x7zHOf8EcN&vx3y&BYHkZM|EWjF5N1VrGQ;!MnN
z1tXSjQz%?GAet9!F2MEIwZpeJii0$TNO=go&VmU{bh~M>BF82HM~p3J!+49L`7=-T
zTyfyTIsEem3a|mR0hjsh3iFnP;k4q_a#gEwl3gL388Hjd8vOPK_%JZQj0GANesl}3
zcUD$cQB`H`GkgmVMmBEPsOmOrT*Wrk)YR~|rR=N<49NQWXOwHRn!a@@L*q$mK&7xW
zPPT!Ctx)u%q2uD!3r}^s{BBzD?TsPRmuo&k6~KL*t1p+=T(Z0wsmy#j73;25Ce2fN
z9AkrInmku_A!)HgbmI&?{sH}Q2W<2Y*qrb1d2C*O5f9HDxMd_Az~?(~k!l$ut%t(2
zEY*J|F~Q{dWZF{@8${6NfY;!r^`lh40S<lQhm=uVUAp|>Yj1#wc&f*N-Sqh4B7Vt0
z5A1EnA)UAF1R{DNgb&ze?B@k|w1=dCeg_{Kiwh`21km8nbStM@7=R~v*(?VlIq<ZK
z!wg<nH-4fUM`dtm+d`YsHel*H;8QuO(~Zs3F9Wn}O!=^~MjXtj2g<9N&C#+leAYxx
z*?^C9nc{)3e5lV#0k>?3<`gd1UC_m2j{pm@e_RjfWX+$b(zEiL7^1zy`0fxv1_JL;
z;8!i1sIjeyn)qmLYv%gkr3So4Y5rVMs3U%LlkuRdDC3Qed?4UsY#QP`i-Una0_P0A
zfQi>bwUOX{-pWfDEnF|nXsw*D@H*>I4xIdm2Gn#>A!utw@%HT1gKoR)hxFZ>zLkl;
zl1Fa`@|U)D-E%@-`XR#y8`{A`>+{l<nn0R%y3`~ZxiA=uwiL7{pVrT-rX;xH(_-)@
z@#Dslgo8}wh3&XKpo7NEu{wz31`XBqHM};MYf)w2YN{I0DHpMoLu?ti<$<*P`2!h0
zA2+D+VRmpLW$fcMFS6~x1Q)k-Vm5X=EZ~(FvFgE>{i2<m)UWzlOqKNORmD#`xvi;J
zT_yGHQDvIEJ7_=$>2`Y1srucURzzYXBlPeWexYo#1bn$NF8KF&3?N{iT&lMHYZ)Te
zvK`Q?nkvndx7Y;v=%iiW^|CiI8P^&dI#AF76b1-paDa}9X<9(X@^qk}a-hQvOlAUN
zJpxb|O$vNZ!iR(=p%Nia?f~2^o0JRy*(xryp4HvBvj!ezB^^1wwa}xo8}+K{7Dy5a
zrZA;IBdT1GrdxsmfesjyLH+k*;FT9?3?jhW%7Y37e7VvMF0GqRqH*EG0|_$=fdK^q
z`->$GR63sc%?yfQoHLh>-^d*7)}G9rU&&yxZ9*A{<4AB7alqHK{BZIaU!Wnw2GMOl
z_yw(5z1E;>I@QqUK7XXizxvYaK1(FO>mCz$Ah91k_K&A%-kb#yoSSL453Vpyms*}D
zJ|_!(ZUa~SE-Z)10Vur#%9~W4;Iil2hV>h;nqi%3;3cD|cCTKv@q@KA?MrWjGJAi%
zp8B6NoGR+7_|Dfx^S?ipR{V9L!H;`sAM-I5WLj1=(!yJ3(#i)G8C;Ugx=;6^VK?ny
zXx!7HTW8SHyXU6b;?n=Oq_u9c`s34QZ8vf92lcC_(?8RnKCx{rO`EroF1=-DNOt(%
zJ?W%F`%$;fxN#Hx{Jw?s$O|hC{=OTxqpAwAWbOK9`prX2=<%0VnRX4CXE-u131sdy
zzK*`}<-wtRP5kB`OX%LGmyyrs+M=}WiGy305dq5w@c{VrquBRtvibfnd}qe{Zm_<u
zVc+k3criT|_&%6ro^{j!+LdKa<?{UMk7pQtdylK5|M%q~Ip+WRAB*WP|5`@iJDd4-
zW4<X4pI_H1APz2FzEY&Oihk8~bnKwLY2V&E&|9l#(v4H^3mDsI@7~+d7Y6S~eQN3m
zQ}(ydc!-`~@qxkLxyuFAsj}Lnmuy;1zn%Luy|i+Q$@gWM#}D3{_Uk>4-dH_@uAA~#
z1K+W37=35E6HMAY{dC47^yJdF3AV)XxwP;X{#BG!avS5>93DiZd6<UlJD@Keb;6Of
z-S};2?yPxq^EE#SRY4Er^AB&B8Iy9>S7x4`crOJ8lx`zZE++q<8c4)7J}rx^@#>YU
z=-O}HM2!uNIV@wg8AZMN^rTMwxlSEO<Pa4JD246WRi|rnvC)e+ssT7@&~gT!q@)wq
zv~sz4h550o+s7fV_{Sc2++29bM~`@mNB@2TwXET(#dSQH8gvjwJ~I!zcoeOEd<iYM
zX*v!1<`^1u<rrG^=n`sO-$Dy+oJMP&S#AaxgRkC(>aQ40s~%cRZOv_zBy;WaD`?8G
zuNd(-bw9W-^*?*Kk%@c~A8;Rs+!8?jYFm2pfhTeaQXn^9Jd)OJXrT?8T6o&l65@V&
zI(KZ(y}5>d@wbI^-mwGeoTCTQGq0~^+E)4{!(M)OEe|lt=)w~Q(%GLINKd`Gihquo
z=oU{V>_d2c@;W+~+lz+1cdVlmC-q~Qt4tg9`IIhe?ECKD^YPFKnA(%$J0p|^zCX*p
z|BU^-An^UEH&)Sl_8qVn-&<pRzx0H9I`^{!>2da*`yToUUn^^!^3-~H<->J!#!Z3m
z4BVG}{}TKDG?ypB?G7KmRcL~HrHaisi$s+RLO>sX;K^|2M)}Mvf|>IGl^fdVx*blY
zRZZ(@Wz#yo-1)7AKrZGb&Kx$8o?7-6-8=6EI$_8@bl%9r>9y6<XcPa`_RnWNO7E_j
zV_x+<dC2~B?ubL_l~q%@W9K#babIG2D$_n_PF_2o&Uy0}p#i&eA3<l2IE4A88?DN>
z!q|c@JlHxCzmdlv0y5n}gjoGpfo=ZMZ(m3o)^DIq8#nPUX<IvCAav{O8rniDFS(SJ
z^ZXR+#uqG;!vD-bLMtSxAOQctPp_rdUVelAboad>+3tINf{s7wXu9m&Z_;H~T}T54
z_A|Ie3l`H4zIUrhe|qA6bQn*icj_$D+gE<)5}qMyrF;K)KfUwj`-TP^Lax5?8`P_J
zPkQyGH|V#&`lEp#^M#{mzk@zS%}vd;V7@%b8U&yA+IJ5+`h?HW2k(AJqsES)y6$x}
zZ}xn;;p!jJS1vh|#%?#7uyoSg+)R_-okG97^-j9+_U{=V?s0tBE%4!T_Q4Oi<r0NN
zb3S+eJowQ#vxYSKBwG}YSdKD!;{GRiid!zgEV^f$`4(;D8~y0t?h+YDbo*paGvl!M
z=d-9~Z8I(8C#>!V_oMCy^`R9HET-lBl&WF%lS`@gQ@yFGe+@Ox-$Y3=+ZtM_Vde&9
zqq=>1Q^Twc)U>$4z>@evhL018C4hP_Bz*n0Su~yN>W3GNhzukqY}3`uIQ*UmjO#bH
z5@rqd*||II#U0?2|5-(kzPKt>^E`LByKPrXeY#iE;uVdQB(tHZmF6zC4<NhmP)l={
zG|;luJb2}h#1|^clkk0yTz5eRorA)!WZ$Q;?>7g&n_ti53+NNubThu+{pey^v$2JK
z#j^(c2EISezCZMm%*w!=f3xqq^K4E(_I)Aye%b9ajm%pw9BIl^uTA(qCurZ`+mn5t
z!@e(F(}b+yo65F;&kiJT{Yocq79MyMgbqu(PxXSAzL@HX2cM!!)6v>Zk=XwscLYmo
zoM)r1o_r6@-?*Hv7;_Bs*$#4S?I1Jb@bIG7Xj5w=J+R<qn%I8=jjtO{udJL(FRYww
z?8WJomD6bdzT<eAqmGs}uAy&#a1YJhxQxC&_L!j47t%)F)3CU~wwGOdjH36~%ryfU
zP+axFpO|ksebeI;Zt+hB5$M=uIm6Z>(WCc2uB4gb+iv)|nTfdgstdw_gqBbX|8i$I
z*TFzj+B_XsS%H}eTTZSb@S37_fghoCyjL*}Xk(5+ML<{s8Z~w#|M&;5gZ1oA)iu>7
zuLFd|3zyK!6|2mEp(hUrG^|;*hL$W|Y6cI0EnmLU<kzlQrzF&w2N~E|ih#ih_-pIB
z(E*3-Yu27H7#KcsXh@Glm#$rmu3dK9iK?rs34@o~?zM(y#OUEPXXZS5`MFoj?8vyC
zx2L`K+r!B6eHhI?sSm0EWs<dAz!OKSBY%~d99wRiikGRnK<6K>e8u4=g7sWo7w6S%
zv#yLyciHVDGl+2IYr18H+~~}*1_R5x%ZgeB?}?DjU~SZ$pWX&vyDim!eGF~jC$$ap
zH=2ua-DG}Z4Q_joXD&Du9K@Bp{@!`}T3UY3ybyx{&Bvj*5=h!`m?RB@h`6w7t=zC{
zd07LYwu{95dt!Jh;gCIg(4{91qH~X}rzvwcnn46GNiqXA6ZPm;L1Tt=roTVCA_QmQ
z3yEVA5#RX&(HlILWw2q+Y?^c84;OGd<vi#Rw0*9^tQ-d{=^)evz7KGGpTxdj@x{UP
z)nf+IhwS?zzD{txO`k7=VZ-R0^m;|yqgy47W#8|Aj%V_MfI);CKqq$bn*(?n4h9j3
zk=H#9a*dbqK7oUn9#8Aou-MES644#91RXi4bCAokNb|Vk1{xuVOnP0jym`>20{7}N
z>QX5WhrO%hz6-nd=sA|YG~@uDsW_BgTRGhf2w>6tO)HF@Mo@49y&Jk!cBW7C97T^T
zej@~95a9;pK@9(}oPk(g(iBSd8#L|)V^>a6dLA!lxWN<+w*&nAcQ}ZM5MWt@ZBfHq
zT#&Y{C<fWlAh!aG(3N>0kyZAxrOVBX!Gzs*rtkge|CyPH`auK20mAQo{U`eA&A-kO
z_bSg~-1wbaXw?dtru)^ccbWWqZ_BzG7%)Tejf<|P58t0^__rUo4Q)SuJCg?8*UrDn
z3={y624qm?w2}uVS6pxvUHi=&>6)*9-@tx+{p~b!`YfvA0fsK4j2u0JTpz9pd>H8X
z0OpkTU}WnljxG+S^ht3VPa4jb2U-joa9LsCz%Trm&5_8PCl-!1ByBuXyt#NHw-Cid
zV|41R8=7g*Rb#1c|2{P2yW1LqiXJkcfSm68^rG(j_NMZh3R=Ol64<7MZU_f%$)byY
zeUDQ(++FFtP8x*A3|ji&BD1?6PldRcgWDi;Gn(`6fs0oDtZYO0@yYyDb}5Pho%+Vc
zR=VKx18L9kwRG_p>y6mju68PTSDuB~V_Yp&SCtWFB?<{g?bjRCPEYX@etUwpEwnkb
zd9)kz76f;ocpIZR7&rirL+M2)t`~dF2#kN)KJfiw-W#+R`+hkOmJsS3-!TjEN#lDt
zJ@?jHeyW$w4s_DVA>{_E=a~I^8Q(FxkshSoV_<;Ih1lo_*=?ML7R*549SeAM&}R-b
zxQK2z>x4*_Gm(5ihXKZFUY<B<$o@2r_cok5>_CI*77Qqm*|Ga@+NaO<Jjke_mwA5#
zW(lw<vx>_=><NU$L<ja6XZBryFG~=AU@ZKtG=mDnC<~MZ%E8}knMJNkgI7D7%pE4K
zM2rga%bM^pKJeXW3r<PkUf7->ck&boNp2^x%;jZ+`oROagO|<%GX!0`b)^;Dk+(Oj
zU$?;&_G+HJK)`Irh|zL$nl*j4X%g7@GN8VHj;iTXXY%?ZE*}1w)=dq(2cw3*cJ;+(
z_5m;qQV=?K>1>uhTpxxxKIAWt{1ir!Ipxy2kld;THWzB;MN^=b1A_!i?;%8P69$sy
zBwBG(5(|)rY}+NIOPPK7`!wME5xhZids_eQYHHooOifE01Ew~be%ZSw-TzBNXz+!j
zY4tP9Xwz&w*`)gmZ12z2)9M$NQ!_7j_(8el`A}?*(kMj~nv{dj`9c<&BpF&?z!xG1
zUSy&7y-mtv(1qaR4KU%PwC)qxwZEB5rySOgzJAIO`fv`fDf7T$8BfJ4%{9N7W27Ck
ze{VYd$N}`?`)g?a5^Wdh9!=sUv)6dWs*(57<O@oHSO<{Gqd3jyw4w+>U=w#7DDgB4
zuVLR$W#6wlWhhNn-?0QEtn^*p6bu>1^WggQBl^+H@2#T+%NUKf3CxwIbt+oW>EU%n
zbU26a*^6HNa4j{l@4&|PK}L`8iVK)+;NO41A9rZ@!{7p1blM-X(ZPy5ZUsg-ljMZJ
zi5$29elYcKbZq_JbR{n}ys>&Zt!vuIgNqGDC-mMq>nU^W&x3+<c~;^>-UG3Omp05R
zv@xyDHRJFByVAdwzss+C>JmkQ5dj!w3BSt9m_Ddn^&fuAeNoFgSC*7r6dr-Gapu*|
zC`lxTB@O6I3=kL*nn<}-BD4%+jZ1MmmL9;_Gvvmw(}Z!fke3nq@$S~H-MXZ{K@le`
z?v0MP5!?JZ^9_6dVBbaG{(a)aQ4{Z<aKoqhby6(DESR^DE;{3D^zWyh57Dy%A9iFP
zuoR*`%ujg>M3|FHEDqzt3dzUOqB7mt23@Maa}MD07rL36z|Hmv-hiY}XA;{dGBCpi
z$jlPf@tW||lU}3OcYB6rT=@Z&cdDdK)7J;AR>tzbFE+65yiX!6=rvcnYY(dAH$fKv
z0aK0s)u>cfl2Q~K<35z{(3upC)976bwLB%ZHfKp`2^QiP>=JrATZ4Lkoa;T!<|Lfj
z>Ed7I4T2ZkJcACq>^-{f?s?Ryx}0V#Y>3E*4Ntr(Gm+RQfsn7Qjvv+4EF0X9O}ar)
z-*pfKu-kr-#$o-=y?1BYbY}`%T0Wj>-6v=RMeobU>+Jja?E9gP@3Yu<6VzDl;IPRO
zVYltNnGO%$^T(A93@5ieU@)=M=x%}UtBh__R<WIwwhEOYwxW*Z)kl;Bb2BeG@FyO4
zinGFFmO_l?(2TqZxTImqx&?Ftzj1NWt3RY)&3c@=RduEXShfgc%3!XIUgk}f2;0=w
zn?a5&47ie1qWCbn>j3J@Z-P9&_)Q~8%SK~MEh&{GKC4#vFJ-_BINT;$C{w+A!p#S!
z7^XTrbR=uu)`&o&8OX>YC(2dAoKar91&IR*+XM?UcE+@sh5@f^K79XUrn5$eJ$Kez
z>f5gmec_a2>9fZlVQ8>_0r}4ydw8g1-8xy@KK<M;8Jxf8AtVeE@4WGzNln;&XFC6~
zvuXIKVLnN0e)&>aSH*0}Ui<B7Hf1Vdnh#2o8|Ri-E+m($aEO&^o>2I5(!m1;40-?t
zy!@qWLGv*Im>Xy07aE`S#*1MWZpd=u#myHKwz0zs=x_t}Ds&ptmCC#Fv>~qvBV8G+
z3D@r3i^@1%&HExo|71M1@KVRBe=nyl+jgV=Ck>{m-ZfM+qzeuI_BKZ3`uElvjTPAc
zz;Y^hN*FRtx+f;m<fhR7)FJ$qNE5C3k2~YV8=GSI)E3v~&5=gAX+VkLkU^i!=%Ai#
zeJN#Ov0FEq4r5lRX-IX`npbVWX>ijnO!+nL&g=EV>pM~BnsVyI2hxB6zbn@-(*5{b
z5!akG)GT$p^8Q*HGpG|C%d-%DYAa|^pK7}F1eyAuHfNJ*w>^3P!wCN72xQ_I&S}U&
zfZSsb>|@@3cysD{(?)fWP|JKn9b1NRx-PH<d}$#KZ=PUdo+`U{D>rs_F}_#O$okII
zvzD(yE^`cudUUHYzJD+9{blxjH2aPjn4au=J^OwMFa023p9BK-e!%xGolu^TDdj0`
zp6Iv(dK%x~n!3TvP+-u3>%0f+9l^A)1!V>q*h?Yp4TA{TBcR<Wp49o%O=eJG6!QrW
zYbXc9!%yp`<BuJr@cs{8s;KYO%PdcHsi-#TuEFxfw%rC(XI{4GUe$%ZI_e0s)bak>
zxm4e|7wyYS8eMt+M9-?Obkg8`jp|t&u$<XO;2&7ild!)+Wx7iuhxh*kEpJ#uQ`g%K
z+7N(!6ULSpKDS<xmV8hO@Yl@B7&Br|C<`~>8y{Wjx>Elk19{(E4e!0HqQOJz&3-+X
zE=)7MSyD<U$B-_t%;q;=$}OW}w8k!N_yt#pU_9Y#c<-(E&EA7L-rP8S>MZkQzxV#1
zR5VrbZ?GeeO_C4Z`;dV@c<;k>`gy0A<q0fNELpUamM*bR9k4C5j~l`AWh-a~%N{vq
zIBm1TSi)WiY{Jypi;y<dDhYg#;-JG0FnW$Z`DkM&mP!y7IX=Aa_y9feAxTRvbrNL=
z*F;dWnpH`Xm!*m<g9PRCW4WL(K#&VdE-Om~JrnsY8oQfWHB0&1=OxR7rHh_N$xRW^
zG573BEBH0H`QMvDeNP`s!*}X#h+Fu*`6*|=WfWKN2Z;t>IEn^eJlf!z*YI~F?wUnw
z-;}4c!RL>pK1a#&6$rM!XE$2<w*@r&dmr+CigN0{doNo2mwATQy%+`=K5Gm3mKnY&
zhPI<mZoMIG4|8j7w|cEV*Jl;#YcR9$icE=B7CuO2>)kRa-a;gG>f!xp((ZQS^v^Hl
zjc_lmpdbI=Li!@Vmb?A%E{1SJLkoT5r?bu19kKcFv?B)48N8f<u#Vqsxc8sS=>6bL
zoRbglPlxQ@!{BiG3CnymkXchzPCJk7N`HTzm$O0&Nu1)@^0UB}TiBK?0c+*1?^=&$
zjsVLF{D-G`#Av`+wwdVIdHW?J%=aK}{l7)@1%4~Z_5Eu<o5lAf?)2FAGuZdD9N+)U
zzP~$jz3I45Icxy?F4qcd{^=znxja|Wt@kb>{=vx5cRWdB=0ooTr?D-$^{|qDa_<t;
z{tSIiA;?1lWE_0df#%H(kYJ;wZAZ4|wLCy`<iOqN=z4oUzh%cW=)MIn(x2x&OGgaY
zjdtrb24u9daUESV`Ol`zI+a(^S;HsMS4PS+>@pq{+&%lBG-EwxBHQRl<~zobdD~8B
z(!KLvpg*!q?4Q`D_xAMX`Og`-?&&DDC5g|qS$W`*3rD>_mf_6}3?eZ2I{cVPwD-Py
zsyO=QcP^vno_UG>aQ9zAn47@M2N8uX(xhz}=b$zVfc3Y-gq+{na0^%M$5$xNKlM`0
zZjm_7F4quzdtw9cq1eRx9|{S0>jSdgw?hiyPih^my>V%Kk%~4$;}QbQ6$_9(d;;Ok
zaz-05H$f*(<AbJ~@A?5<eClPKvU-uiAOcS}Sp)RqhF?9j3$^hpY>f-O-Q_H>nxCZF
zc;{S$xAQ!kj_kH%r_83=r-FPOxJ^pBeHyjiBo=K*Be;^IX*U<8Q(loEZNjD{^~1Yv
zqDxM_T)`&x`65WpKx6c<ExevTl+?^?`Ab$dMc6Ri+rL*O?@uZ-Z)=E;+C>Ygz#?oN
znz@;Mzu5B~3gL~}oX4{g2xiS43G<YR!3FGAYlGQ9rXAF$%Ix7-w6Y<<o6DMImC*p>
zJ3qK^xyYgemmuV^EL~5>phb1d{sxfnCzrXSSB=qHgmIt|8)Ux&W)>kQH$b-eWBQx!
zxSqat`ZwSdi{RM`qXY8bmjqV^_z=uFK)Com{E;Zgz;_`uKoWfK$zQfar@W$JtwBlI
z8Pk<CjIH(%6q|5$#}arzm;OgFZQdovYL(8`s;w?QHO;)8J9jp-^R7;pr-eVB(!k$U
z(!F{vZgZsZEeyPs=zkL<>u+uF_|}FbCoRS1O%-C#ie>K9c78im_B!YF()?T<L!q|F
z4L~l;GV`QSygoE`oo&$Pr>xS{9(<6>4S*Luh`<FXH;4w_a26NZ_)9dK%(N~v;3($S
z0UnnZ>D-`_<FUE)X%LlxSOyMyYfa-y#=$o293-7g3ygZ~r=ys(($vz3>cJj~qyS%C
zzoi?pusFU2;ig)_s-G=9aGbjg@84K>9RKEoC9Rdq^@L>rew8w)Z9L)2fI><^_ex;F
z0G&=54+7B}KI;Gg6Us?MK~&}}<+l;|4{r&Wx@CUd{I_s9-anE67_L_UAg!E#-3c8o
zHdmrEZsoTwR0haEgX<c>>E}&FU=V><DG}?;tjUAeR9;Yn%&33x3%=twC^Q7pg+~ol
zq=^C4)(}CM489BD2T()T@<tgz2;K?@-sS|GtU>UFp5x>t)jMS4GvwGzspVa;K2wjV
zv8^{~+bq_?a3Ha@IoVP6bd+4T0<!7=ojrnv7F<PXGW-h-x&hMxgEn}j(-?FJX|i3M
zOz{c?XLOc@%tSz!+Jtm`KoizrQwm9seR?;KwChb&l1mxIBy*`Wf3`v4zMQl?^vg|L
z>dv*tP5Uyk=mLK>I#7u=S0|=;U4EqHuuz-wEwp)+S&W}n%H~bE%No9B?UY-1_rK}v
zxs%6hi{hVpYq<cCXM4U1%sM={<P}8l=n{#Rk5mP6=)5p^fGm`>$VMlRL5X?8g2DK`
z3B`d@gV7QUBCKs9BM=pk3M|0TqmcomLYdS_S{+C^tw3oUkkaPFO6wr3msV;FnZqGT
zUtN6OLTxH4>Ph|x8+L>sK(DDE&g!e=QY!{s*okFeRw!Q(o%yIb5TB*6Q`8#|lL{An
zSlgLBb8d==(xPBXnmxs6Q<<fcn_Z&nR1V!(hbMb9TpWPe&MDb{x3M9OPFkniw86`5
z4LH3ZiYYPS!O{kTYr9~wonfEaVL8+biE-|jpe0|tbVxwGNL@*ct!r9mS}yrC#MKq*
z3(tO-t<f^llF28}#V3_t65Qo=dkFOv{$goE+h&}<e#xrc+8(t{YFr9Gqjr}zr}jfC
zmNwjct|sYHOh?0m2wb`N!&PGV_=FfiFmjfwoV$1~Jn*8kui&lG=6eRFw83FzW6**p
zcX<vLxRh^e@S!NsTV0Y90I1EcU~=oS{DAs@QU06nyiowG*97BGD48vGLo^4Bfp|PF
z2dg*oT~0rZydEf3J?u3o*B{!YwoSCv^t`=>Rh}Q;bk~icuCm~}A^0u?W+G5(#Rsl=
zUc!^Y$tR^fdh*H6fY*9=Nayiek$71mU#N5|GL9JEUg*N#R=^&FLYEKX<i)}A*$~H*
z1y*{w`6Via8=EHtHdq?3VzRX@ziDZ+4z9`I){vz%gvM&m<w?WA_B6aN4fdgf%ngv@
zdzDMoeh74^#jZYuiH2xSH~_;Tmk(+$dr(bs%MR|#%&u@qaxKd)St!$Zqc~WQZoAGd
z#rYQpQ(M&+#IB#fD^6+MSaC_R^WjyN(rF%Xl1!H-jxP<b^f|Kmh6^0l&C9s6)&Ya*
zw9U>|V3o_p7({3=5}4N98)S4L-)sPZDh|@nV}bJUAT%x^Xe5Yr)&e)BG$vLvjTn^`
z#F`Bl9MeP3fO6phX(S5qjyxnoxJkP?9~TkVp&8hPS30rShJn78V|$dsv$WsWXpiht
z^1^qgii~LdN_QvT+mU78M!2+*X4Ja1>&!={N;Qy(Hk&lfh2css7ZUwuA8(VZ8)=<o
zkPg_z3V$xd%5^JLDp;Ddq=imsTuRHIluFZ?ixUXWcpA`7CrP#scLzK^E_$md%!gcA
zX%Jtw^~vSZK~hp(xwLU<XmR~jt%&_{Rh%m)j?TsV=`{K%&gNi;Z;P7;Wl{i6Z>y5d
zz3I5TR%<+6nl8x6hj(>px)>hi%@@0}-7>@G1mN)73K$Sz9|8swG7Es&CT}Pm2vQlY
z+_2Mffohloiw-K7z`-ebE(}DfHKY>eIDVHTmJ_lt2tshrnlp&-WX4uuE}q6g7nD@<
zH3qYrjtT=tY<J;GzlrOyR0D`mKC8oCm(qG2N-tdkZP}ZVz;9x$UvD?crYXxbkic(X
zbmt$tDn*cHR|-j1M(JcilH1rcZFR+^&;iMzOB97$q>UM|d((FHDUF4xy%wS=A5)k`
zmRkK%xmjX#s@^R$3tI=#L`woW88B#Uea&KkUq8N|ejWLF)#1Z6pVb=BE3KObOb$C6
zp>(R-ja9D;Lt2-}fKQ@vd3+mOT$Z$NV-}rR<d&MowJWq4H(~BA(FtKN;SMO`^t&=b
zd@L};+C)aW(6*2>BV$N!+m{34wgt&{t_wNUr7`Hu;K2m|m=NMD15Du>%bih#SXfl3
ztI}QpYNKFXIPO*W1UdqiGCCq;nvp;!p5#<V80E<{16fahZC$PTxd@LmHk)xEvCMn}
zB3431pj*KiSyIVLEzc@b$r@XXrhw57RyrlOX)0BEtaXN12M#WW;$2vw>0}S0lA?6c
zT%j`&uv;(3WFG{RjE~wUIkhVbm!(AtwWEUvq!k;d#fL!~>IXhaI!cknnkYwl&X<>D
ztHQ-Uw8wbAl+M?xdekSs4XVFBpPN@13Pax4hrCax^lqGm#--mH(z!Nc*#Wy=ypT)i
z5tKIT*FmAuU4Hj^0bCB3LZs(Ha<%%!pm{$QPKCO1q>ZaCjX~k2U5=zQ1`tib;1B7J
z3w-b48Hqye>o|K7By$m%!GweE+qX9lB<v63IjEc@?yq^n%xSY|haKg|vGNjo1Sr5#
z6{5;2jXYPHraj|>EU=i~$A+Hj;K1jnkx#mT$4NqSMWe;jo^C`#tT%1o^@!t7@;eD0
zC&PzDd2LP`hK2Z?@p<?MACiN`7AD&*8F1>Mn&g&;Gi=8QSw0ai_2zDnR1QCe2CW}F
zUFt8BVzVIXC~H0Wa@&))r6nH2H{E#VZZPx9QuA7B8p8+O;3+ZMU$hOvURN*jZcte+
z3~AMgg!?7G5biT<WqI{E$-hK%)j?*&^spYL5LIX*b7>GTL60mFl@>ADls+(^O+_~^
z+V%!I(8mQWv$R<Glt%Mvi`Zf9fla#US7Kde6&mGBvPtD@483UUjl6_`Wen_v(3v--
zDRnHX8d)tYwf4f~nWYV9d1Kq{$Ixv4B6XIKX+~no2h(U7e_isZ;|`}s9(=<5<aV0y
zQWjh3WMz}2RETltKtV1d#in_0adN>($Le1^N)<{(0z^r{!+Y5zu2guaJEXExmhiXG
zpdC^?Uz&6A98qYlwF0qEDagx_?Fk^Re$+~hqc&`woO){gDa<ceDZYulHZ5NHzWMol
zUcxTranqL14(eL@hK(DPOJ{DbmRM4OK$YvGOPSBAL+N09YEZ&dqS7Gq+Ty5jX(jER
zwM{t;oGkRZhwHAMsI>T8q4d6#q~cD4<KBdydp9u)%=ftC>ntkIj^bM$?e(`P-Ni6*
z0iq0R_><oUPTZfr8oiRgNIf%?q_S-W@0e8n5drvB%+K?uq<5S!-h5j;g8Vr1aS41}
z0w0&a$0hJ_34B}vANdk!YHFhQ-kD7I^Uqdn+!*}|aguYH2NEg(@5Hvsmr@L<l%uUu
z%2IpN#>>zr(`hmtuG4##H-8GFFpO?x>f6pffYbFSnzlKc%C8F)?x;`F7GhJ$vXb@L
zCwok978+!?bCfHKJ?c>!t&ZtsR>;m0MYYA}AXn>0(yB3@ese)l!g`2b>SZ<y@MM+M
zpSaqLD{mKOcw(jwER9WBi{XPT_u<V2d?NuLO~Rj+I`HNTjXX;sZ#Re>Y*0kNn-1a`
zb2!ti1{rgTvm%D9-JrNKY`0KHKvwxa9r9A@B24m*;5<o`pO&G-TKXyv((S!0PJbR1
z5wz-3pyoAJxW>imgFMVY@JFZ3CRmlXIb+O5R8{d074j2)zR+wwk<Fh`cly?RJf+50
z@^4>t>cpSPuH@g8DbS8gOB=4i7)1D$>*5PdmrhoGNua<XYj4pDun@a(tBV^r6e6P(
zwD859G?sj_WZ>h1+$yAOuohWpNLpviXOHL+syMB%%N;yqu?sg4f8gNq$!#)Dn@g21
zt+&1GazKfrP=8<vv}yM${s9^v;w(~Y<2mA?_&o>h+)-xohgPovb)yS^48x#<JAVBG
z6~5dE3bawNL9mf8G%_6q3^Lfj8aPTw>JYD0`h$sLd@%xxJjIn~p`ug<Y}a&F8A^{>
z2MjJOiyY|Ha+9>?L?&d2e5)giT+moaSvjI~h58cZ&ds5PHM3B>fsu4y%H`@H2-{JH
zk5PR@0<JZ46gY^0dj$<7N>wE7mjelC!uciXjT;>#sP$sxWafazsRIYSmA3Z+N>i@h
z#nGhUKp%$(EIvq?00$Z^t9aUYsCIDi*ep;jNv$8(4r^bMB<Y&$Mo7@9#H2PN-I{i8
zNs_a`ttPiEYI$p!O4lfDFP~IMjPnV6t~OVW>hoz_xS?kNU^#LCa1oq_4f+NGP-fV`
zGYkmkW)n!!0f0;%L?z>@DQBK?{`diI>Kf#Fl0kyju=(sW6Ub+yg|ZUAGhv1peAQWY
z6;tvUewHf4$%=!iKE)xHLrX^TN|zLC@gUZ;ORMswEn3+wO}=!TT;);uNqL1Q#c8sW
zcw9K{LwJo7GoyO1cJW&#&E*_3tG8ur$*<L1!*U_#C-x{Z4J7<V;>pOAErpDzqFjjz
zkq*&5&Em3ATvSGUPHuE^L24S5{zY1d%y>=7P?a6IzyOQ@^!^`3C~vZK@I|RmW`!>8
zXxVrsrKyeJ!~(aTa_x#Ra7O9?nl+tMBo0f|M<86k6<fId;8ZS=2#9|~wLyC{s04W9
z`=huhM-e$T%Jmr%U?+m;;Bx>llL~?|ShWE$ej*ACD$9*wJw$*`JmG{%bDnQZX2TgH
z1ur<sq3$ur;9&;n^e+$wm>Z%w7gJnX%b_@K;VMLiORH(|IVwwWadv4LXdFiaepiN@
zj-v<6mFK3F-j(5|6^}Rx?$We3t+pZ7>jq007^vbcB)9#wS66%aQ67br38>Y>_G&MJ
zpRYIhQM$r;V+Rt2IiIYwRB}W^yfi@VA)S&AB$6$QVx;P%3F>H88miDCt=ct?N+?~<
zmyf*PwBlgaLfGPSsC^>c*HPRcB03A88vNL`RrMmahjvLmr{u*GTQ};N#_?Q*L0ud3
zaatcFg|oId#U;s5oAm~WJlY$A;v`qtS$Tc^fNSS0C9aezUnr1M4BwLtDfrx*vZggw
z?^Qkq3&t;}^EY{h>Jo_2p?IdppU!BBTp5tymv1eP3}DpaVq?E-I#Q0S%TJ5fqTR*C
z*`sv=oS#-+KaP{5Fjq#LOu$s0rrkVXe#nRS>HWNKlj0SQ*rv6W2n?UIM*Gn=q`X^A
zjKcYd%t)x2ZTyoMZRNqD5DK1sK$|teM4SV0kQRiqv=NXhyy&<zav&w}BE}Ncp&g*c
zF{G&=G)o;gAl3%!GpRlwo|ezTlZ6I4Kxb@AFi_<P+9gs>p-?*4ZorD!7a^U5D=9e*
z9eOyc>d6d@(VIhBy`&1rh;&QKWl1V4z_Sh<RGw{TQje}qq#@IVfiF%!;Auf+#PLc8
z7Tg2^A-Y5%w`TxZf??+O_jy^tK=70j)`kHIJUEBEhBeT_`zs`cdPEJP%*r{%&y0by
zig!0x1}L^dItTFivl4)14RPg=l^1kb`F%R%<$#yj<)Hrb;G_vE+m98W7OO185;P@t
z0j6@%rZ-nmD^#Crr=*2K>HHW22<hq+qms6+Slf6OtF)bLPLE_fAZ<Z^SFEkMnVMSo
z%Q<X_UfZ%f!*pyUzS0>vf)PmGAMMIo2wCW|(`a!b)}}5gbb2~)u$b(U(Lw2lcvMSv
z?ov=DTb+yvior1$v`*F-Ca|a!d&|hR9hAikB2b3XJxHDScBm%E&)Vrq=OI3+Y?ZS)
zV=X;5&gz5O=?{Y3@^RBj@55BL;@ca`0)j}fKV2<#hxUPOmAK4QFYJ*HTr4xQ1Hlag
zQczczSkNJcNESHGyye?~L^j`eAQ&ejSgC_IG<1f7!J<v^X*s3Ijn#)-Ogf}cKI0OL
zlvu8^EHcz9uPBUhDzlJIUFAru(#2P`P1-MDSu7OZ_MW4b*t%7FRld?m?4FfEtZrq~
z<=$;tpG9u%sm)j9nMwkeA%^)faL6^zJX~m{1QOkQ0r8B52E4&pUcuX=`G{TGP{Oo0
z*Mv0cVsLVC;vz7P2XUd2w1d*l&nu%s#kHG0Qf|m(Gze49K4~0#M1G33ptCoa6haRL
z8+<!JqI#`dg?IvjtjLi8i7U@d$8#12b*+d?114~3Z-q%0YTL%7Y|?yyF3_viIDIbG
zwb`Xj)FBFll+)0qn<fF&&Ru>;hymP@8+%xw41h#3=*%DAdGLo2P?|JuNEm{EKW@gt
z5b+7RTLNQ^o&bRXO(8)nfDJY%%tErK3gHE<J)|_U@WWQMS7R$juD>i6E3e3NOHu7I
zHDRpGVpkTOS!u*3p;kN7c$G%&)EGS4&Rm%J!YtqX<n?mpPSdaz;fy1$Hz~G(EF)=(
zlvq@B@Bot1D8d_@ZEgHR>&-3M2NI=G9p|T&jFcYsEeqSg;<$a7-t2Ij(kDaEY{@2Q
zJq)Y`00tFe6!T;qOaxjIBdFH_S|U*b!Yxyfs4T?!Y6^9OdQrFi*oa6tiTo(ig=sn(
zYtHiJLM$#zN~%q6=911{mFlmQT7GS?6`z{MpR{W|s{|`CBF%GBtOW%S!N9_>>aAP2
z#UGIwzSF|{6|6W(;S4CIJTV}N3<?~RtX`3?XNN>VCboJa;7BG5O@x6nS$UKWu^g`N
z$#T>mja9$OK_1szz5sreA+hGbDYoG3%2J#2$u0)3+TB>wt~}oc&HJ&-gS6sZxXRbx
z!O$fPg}byLg>;;c@pfmYjOWjVVgO<KQI17=>2=7=WE=f|O%WkGaZ@3600000NkvXX
Hu0mjf+?nfp

literal 0
HcmV?d00001

diff --git a/forge/readme.md b/forge/readme.md
index 89e4c03..e1b3604 100644
--- a/forge/readme.md
+++ b/forge/readme.md
@@ -34,4 +34,5 @@ forge t  -vvvv  --fork-url https://arb-mainnet.g.alchemy.com/v2/vkR4jribNoIWslgA
 ```
 The above test forks the Arbitrum network at block `8623683` and interaacts with stargate through the vault by replicating user deposits, withdrawals and compounds
 
-To test reward reciept, `testRewards()` will need to be uncommented and the test run on ETH Mainnet. 
\ No newline at end of file
+To test reward reciept, `testRewards()` will need to be uncommented and the test run on ETH Mainnet. 
+<img src="./gas-report"/>
\ No newline at end of file

From b2dd7731062d75be92c5fd433da339b0ec46311f Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 14:38:00 +1000
Subject: [PATCH 07/45] img

---
 forge/readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/forge/readme.md b/forge/readme.md
index e1b3604..c19831a 100644
--- a/forge/readme.md
+++ b/forge/readme.md
@@ -35,4 +35,4 @@ forge t  -vvvv  --fork-url https://arb-mainnet.g.alchemy.com/v2/vkR4jribNoIWslgA
 The above test forks the Arbitrum network at block `8623683` and interaacts with stargate through the vault by replicating user deposits, withdrawals and compounds
 
 To test reward reciept, `testRewards()` will need to be uncommented and the test run on ETH Mainnet. 
-<img src="./gas-report"/>
\ No newline at end of file
+<img src="./gas-report.png"/>
\ No newline at end of file

From 8c69543c9a8e60ecd5b8972fdcb1c8905006a13f Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 14:38:43 +1000
Subject: [PATCH 08/45] img

---
 forge/readme.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/forge/readme.md b/forge/readme.md
index c19831a..f00863b 100644
--- a/forge/readme.md
+++ b/forge/readme.md
@@ -35,4 +35,5 @@ forge t  -vvvv  --fork-url https://arb-mainnet.g.alchemy.com/v2/vkR4jribNoIWslgA
 The above test forks the Arbitrum network at block `8623683` and interaacts with stargate through the vault by replicating user deposits, withdrawals and compounds
 
 To test reward reciept, `testRewards()` will need to be uncommented and the test run on ETH Mainnet. 
+## Gas Report
 <img src="./gas-report.png"/>
\ No newline at end of file

From 450cefc49d69cfae60615625fe83c3f4cac78931 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 14:46:35 +1000
Subject: [PATCH 09/45] forge install: forge-std

---
 .gitmodules         | 3 +++
 forge/lib/forge-std | 1 +
 2 files changed, 4 insertions(+)
 create mode 160000 forge/lib/forge-std

diff --git a/.gitmodules b/.gitmodules
index fefdd27..ff203b4 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -16,3 +16,6 @@
 [submodule "forge/lib/openzeppelin-contracts"]
 	path = forge/lib/openzeppelin-contracts
 	url = https://github.com/openzeppelin/openzeppelin-contracts
+[submodule "forge/lib/forge-std"]
+	path = forge/lib/forge-std
+	url = https://github.com/brockelmore/forge-std
diff --git a/forge/lib/forge-std b/forge/lib/forge-std
new file mode 160000
index 0000000..8f1a972
--- /dev/null
+++ b/forge/lib/forge-std
@@ -0,0 +1 @@
+Subproject commit 8f1a9720250512a49c6638979a87613700e2a68b

From dd0b00a21723e5688397ae08ee762256cec151be Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 15:25:49 +1000
Subject: [PATCH 10/45] test utils

---
 forge/remappings.txt               |    2 +-
 forge/src/test/utils/Console.sol   | 5203 ++++++++++++++++++++++++++++
 forge/src/test/utils/Utilities.sol |   38 +
 forge/src/test/vUSDC.t.sol         |   51 +-
 4 files changed, 5278 insertions(+), 16 deletions(-)
 create mode 100644 forge/src/test/utils/Console.sol
 create mode 100644 forge/src/test/utils/Utilities.sol

diff --git a/forge/remappings.txt b/forge/remappings.txt
index c783553..45dc358 100644
--- a/forge/remappings.txt
+++ b/forge/remappings.txt
@@ -6,4 +6,4 @@ openzeppelin/=lib/openzeppelin-contracts/contracts/
 foundry-playground/=lib/foundry-playground/src/
 tracer/=lib/perpetual-pools-contracts/contracts/
 abdk-libraries-solidity/=lib/abdk-libraries-solidity/
-
+forge-std/=lib/forge-std/src/
diff --git a/forge/src/test/utils/Console.sol b/forge/src/test/utils/Console.sol
new file mode 100644
index 0000000..a837d22
--- /dev/null
+++ b/forge/src/test/utils/Console.sol
@@ -0,0 +1,5203 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/* solhint-disable */
+library console {
+    address constant CONSOLE_ADDRESS =
+        address(0x000000000000000000636F6e736F6c652e6c6f67);
+
+    function _sendLogPayload(bytes memory payload) private view {
+        uint256 payloadLength = payload.length;
+        address consoleAddress = CONSOLE_ADDRESS;
+        assembly {
+            let payloadStart := add(payload, 32)
+            let r := staticcall(
+                gas(),
+                consoleAddress,
+                payloadStart,
+                payloadLength,
+                0,
+                0
+            )
+        }
+    }
+
+    function log() internal view {
+        _sendLogPayload(abi.encodeWithSignature("log()"));
+    }
+
+    function logInt(int256 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(int)", p0));
+    }
+
+    function logUint(uint256 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
+    }
+
+    function logString(string memory p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
+    }
+
+    function logBool(bool p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
+    }
+
+    function logAddress(address p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
+    }
+
+    function logBytes(bytes memory p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
+    }
+
+    function logBytes1(bytes1 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
+    }
+
+    function logBytes2(bytes2 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
+    }
+
+    function logBytes3(bytes3 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
+    }
+
+    function logBytes4(bytes4 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
+    }
+
+    function logBytes5(bytes5 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
+    }
+
+    function logBytes6(bytes6 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
+    }
+
+    function logBytes7(bytes7 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
+    }
+
+    function logBytes8(bytes8 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
+    }
+
+    function logBytes9(bytes9 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
+    }
+
+    function logBytes10(bytes10 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
+    }
+
+    function logBytes11(bytes11 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
+    }
+
+    function logBytes12(bytes12 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
+    }
+
+    function logBytes13(bytes13 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
+    }
+
+    function logBytes14(bytes14 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
+    }
+
+    function logBytes15(bytes15 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
+    }
+
+    function logBytes16(bytes16 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
+    }
+
+    function logBytes17(bytes17 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
+    }
+
+    function logBytes18(bytes18 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
+    }
+
+    function logBytes19(bytes19 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
+    }
+
+    function logBytes20(bytes20 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
+    }
+
+    function logBytes21(bytes21 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
+    }
+
+    function logBytes22(bytes22 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
+    }
+
+    function logBytes23(bytes23 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
+    }
+
+    function logBytes24(bytes24 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
+    }
+
+    function logBytes25(bytes25 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
+    }
+
+    function logBytes26(bytes26 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
+    }
+
+    function logBytes27(bytes27 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
+    }
+
+    function logBytes28(bytes28 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
+    }
+
+    function logBytes29(bytes29 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
+    }
+
+    function logBytes30(bytes30 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
+    }
+
+    function logBytes31(bytes31 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
+    }
+
+    function logBytes32(bytes32 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
+    }
+
+    function log(bytes32[] memory p0) internal view {
+        for (uint256 i; i < p0.length; ) {
+            _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0[i]));
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function log(uint256 p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
+    }
+
+    function log(uint256[] memory p0) internal view {
+        for (uint256 i; i < p0.length; ) {
+            _sendLogPayload(abi.encodeWithSignature("log(uint)", p0[i]));
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function log(string memory p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
+    }
+
+    function log(string[] memory p0) internal view {
+        for (uint256 i; i < p0.length; ) {
+            _sendLogPayload(abi.encodeWithSignature("log(string)", p0[i]));
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function log(bool p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
+    }
+
+    function log(bool[] memory p0) internal view {
+        for (uint256 i; i < p0.length; ) {
+            _sendLogPayload(abi.encodeWithSignature("log(bool)", p0[i]));
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function log(address p0) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
+    }
+
+    function log(address[] memory p0) internal view {
+        for (uint256 i; i < p0.length; ) {
+            _sendLogPayload(abi.encodeWithSignature("log(address)", p0[i]));
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function log(uint256 p0, uint256 p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
+    }
+
+    function log(uint256 p0, string memory p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
+    }
+
+    function log(uint256 p0, bool p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
+    }
+
+    function log(uint256 p0, address p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
+    }
+
+    function log(string memory p0, uint256 p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
+    }
+
+    function log(string memory p0, string memory p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
+    }
+
+    function log(string memory p0, bool p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
+    }
+
+    function log(string memory p0, address p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
+    }
+
+    function log(bool p0, uint256 p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
+    }
+
+    function log(bool p0, string memory p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
+    }
+
+    function log(bool p0, bool p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
+    }
+
+    function log(bool p0, address p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
+    }
+
+    function log(address p0, uint256 p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
+    }
+
+    function log(address p0, string memory p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
+    }
+
+    function log(address p0, bool p1) internal view {
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
+    }
+
+    function log(address p0, address p1) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,address)", p0, p1)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,string,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,string,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,address,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(string,address,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,string,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,string,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        uint256 p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        string memory p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,address,string)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        bool p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        address p2
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(address,address,address)", p0, p1, p2)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        uint256 p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,uint,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        string memory p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,string,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        bool p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,bool,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        uint256 p0,
+        address p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(uint,address,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        uint256 p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,uint,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        string memory p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,string,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        bool p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,bool,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        string memory p0,
+        address p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(string,address,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        uint256 p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,uint,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        string memory p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,string,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3)
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        bool p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,bool,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        bool p0,
+        address p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(bool,address,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        uint256 p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,uint,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        string memory p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,string,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        bool p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,bool,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        uint256 p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,uint,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        uint256 p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,uint,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        uint256 p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,uint,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        uint256 p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,uint,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        string memory p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,string,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        string memory p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,string,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        string memory p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,string,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        string memory p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,string,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        bool p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,bool,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        bool p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,bool,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        bool p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,bool,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        bool p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,bool,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        address p2,
+        uint256 p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,address,uint)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        address p2,
+        string memory p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,address,string)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        address p2,
+        bool p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,address,bool)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+
+    function log(
+        address p0,
+        address p1,
+        address p2,
+        address p3
+    ) internal view {
+        _sendLogPayload(
+            abi.encodeWithSignature(
+                "log(address,address,address,address)",
+                p0,
+                p1,
+                p2,
+                p3
+            )
+        );
+    }
+}
\ No newline at end of file
diff --git a/forge/src/test/utils/Utilities.sol b/forge/src/test/utils/Utilities.sol
new file mode 100644
index 0000000..18c0ed9
--- /dev/null
+++ b/forge/src/test/utils/Utilities.sol
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity >=0.8.0;
+
+import {DSTest} from "ds-test/test.sol";
+import {Vm} from "forge-std/Vm.sol";
+
+//common utilities for forge tests
+contract Utilities is DSTest {
+    Vm internal immutable vm = Vm(HEVM_ADDRESS);
+    bytes32 internal nextUser = keccak256(abi.encodePacked("user address"));
+
+    function getNextUserAddress() external returns (address payable) {
+        //bytes32 to address conversion
+        address payable user = payable(address(uint160(uint256(nextUser))));
+        nextUser = keccak256(abi.encodePacked(nextUser));
+        return user;
+    }
+
+    //create users with 100 ether balance
+    function createUsers(uint256 userNum)
+        external
+        returns (address payable[] memory)
+    {
+        address payable[] memory users = new address payable[](userNum);
+        for (uint256 i = 0; i < userNum; i++) {
+            address payable user = this.getNextUserAddress();
+            vm.deal(user, 100 ether);
+            users[i] = user;
+        }
+        return users;
+    }
+
+    //move block.number forward by a given number of blocks
+    function mineBlocks(uint256 numBlocks) external {
+        uint256 targetBlock = block.number + numBlocks;
+        vm.roll(targetBlock);
+    }
+}
\ No newline at end of file
diff --git a/forge/src/test/vUSDC.t.sol b/forge/src/test/vUSDC.t.sol
index a86a93c..b422e04 100644
--- a/forge/src/test/vUSDC.t.sol
+++ b/forge/src/test/vUSDC.t.sol
@@ -5,28 +5,31 @@ import "ds-test/test.sol";
 import {vUSDC} from "../vUSDC.sol";
 import "../utils/ERC20TokenFaker.sol";
 import "../utils/FakeERC20.sol";
+import "./utils/Utilities.sol";
 
 import {ERC20, ERC4626} from "solmate/mixins/ERC4626.sol";
 import "openzeppelin/utils/Strings.sol";
 import {IStargate} from "../interfaces/IStargate.sol";
 
-interface Vm {
-    function warp(uint256 x) external;
+// interface Vm {
+//     function warp(uint256 x) external;
 
-    function expectRevert(bytes calldata) external;
+//     function expectRevert(bytes calldata) external;
 
-    function roll(uint256) external;
+//     function roll(uint256) external;
 
-    function prank(address) external;
-}
+//     function prank(address) external;
+// }
 
-contract vUSDCtest is DSTest, ERC20TokenFaker {
-    uint256 count;
+contract vUSDCtest is DSTest, ERC20TokenFaker{
     vUSDC vusd;
     FakeERC20 fakeUSDC;
     ERC20 UNDERLYING;
     FakeERC20 fakeSTG;
-    Vm constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
+    Utilities internal utils;
+    address payable[] internal users;
+    Vm internal immutable vm = Vm(HEVM_ADDRESS);
+    // Vm constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
 
     function setUp() public {
         fakeUSDC = fakeOutERC20(address(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8));
@@ -63,11 +66,29 @@ contract vUSDCtest is DSTest, ERC20TokenFaker {
             0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
         );
         vusd.deposit(1000000000, address(this));
+        utils = new Utilities();
+        users = utils.createUsers(5);
+
+    }
+    function setFeeFail() public {
+        address payable alice = users[0];
+        vm.prank(alice);
+        vusd.setFee(100);
+        vm.expectRevert();
+        assert(vusd.fee() == 0);
     }
 
     function testInitialBalance() public {
         assertEq(1000000000, vusd.balanceOf(address(this)));
     }
+    function testUserDeposit() public {
+        address payable alice = users[0];
+        vm.label(alice, "Alice");
+        assertEq(0, vusd.balanceOf(alice));
+        vusd.deposit(1000000000, alice);
+        assert(vusd.balanceOf(alice) > 1);
+    }
+
 
     // // test whole deposit flow
     function testDeposit() public {
@@ -78,12 +99,12 @@ contract vUSDCtest is DSTest, ERC20TokenFaker {
         emit log("deposit");
     }
 
-    function testDepositCompound() public {
-        fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
-        fakeSTG._setBalance(address(vusd), 1e18);
-        vm.warp(2 days);
-        vusd.deposit(100000, address(this));
-    }
+    // function testDepositCompound() public {
+    //     fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
+    //     fakeSTG._setBalance(address(vusd), 1e18);
+    //     vm.warp(2 days);
+    //     vusd.deposit(100000, address(this));
+    // }
 
     // test just reciept of LP tokens (comment out stake)
     // function testLP() public {

From 046a6804b96649b4f942e56a4f6be053a7eddb59 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 15:34:35 +1000
Subject: [PATCH 11/45] natspec comments

---
 forge/src/test/utils/Console.sol   | 2740 ++++------------------------
 forge/src/test/utils/Utilities.sol |    7 +-
 forge/src/test/vUSDC.t.sol         |   25 +-
 forge/src/vUSDC.sol                |    6 +-
 4 files changed, 343 insertions(+), 2435 deletions(-)

diff --git a/forge/src/test/utils/Console.sol b/forge/src/test/utils/Console.sol
index a837d22..f5cf485 100644
--- a/forge/src/test/utils/Console.sol
+++ b/forge/src/test/utils/Console.sol
@@ -3,22 +3,14 @@ pragma solidity >=0.8.0;
 
 /* solhint-disable */
 library console {
-    address constant CONSOLE_ADDRESS =
-        address(0x000000000000000000636F6e736F6c652e6c6f67);
+    address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);
 
     function _sendLogPayload(bytes memory payload) private view {
         uint256 payloadLength = payload.length;
         address consoleAddress = CONSOLE_ADDRESS;
         assembly {
             let payloadStart := add(payload, 32)
-            let r := staticcall(
-                gas(),
-                consoleAddress,
-                payloadStart,
-                payloadLength,
-                0,
-                0
-            )
+            let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
         }
     }
 
@@ -300,9 +292,7 @@ library console {
     }
 
     function log(address p0, address p1) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,address)", p0, p1)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
     }
 
     function log(
@@ -310,9 +300,7 @@ library console {
         uint256 p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
     }
 
     function log(
@@ -320,9 +308,7 @@ library console {
         uint256 p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
     }
 
     function log(
@@ -330,9 +316,7 @@ library console {
         uint256 p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
     }
 
     function log(
@@ -340,9 +324,7 @@ library console {
         uint256 p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
     }
 
     function log(
@@ -350,9 +332,7 @@ library console {
         string memory p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
     }
 
     function log(
@@ -360,9 +340,7 @@ library console {
         string memory p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
     }
 
     function log(
@@ -370,9 +348,7 @@ library console {
         string memory p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
     }
 
     function log(
@@ -380,9 +356,7 @@ library console {
         string memory p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
     }
 
     function log(
@@ -390,9 +364,7 @@ library console {
         bool p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
     }
 
     function log(
@@ -400,9 +372,7 @@ library console {
         bool p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
     }
 
     function log(
@@ -410,9 +380,7 @@ library console {
         bool p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
     }
 
     function log(
@@ -420,9 +388,7 @@ library console {
         bool p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
     }
 
     function log(
@@ -430,9 +396,7 @@ library console {
         address p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
     }
 
     function log(
@@ -440,9 +404,7 @@ library console {
         address p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
     }
 
     function log(
@@ -450,9 +412,7 @@ library console {
         address p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
     }
 
     function log(
@@ -460,9 +420,7 @@ library console {
         address p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
     }
 
     function log(
@@ -470,9 +428,7 @@ library console {
         uint256 p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
     }
 
     function log(
@@ -480,9 +436,7 @@ library console {
         uint256 p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
     }
 
     function log(
@@ -490,9 +444,7 @@ library console {
         uint256 p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
     }
 
     function log(
@@ -500,9 +452,7 @@ library console {
         uint256 p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
     }
 
     function log(
@@ -510,9 +460,7 @@ library console {
         string memory p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
     }
 
     function log(
@@ -520,9 +468,7 @@ library console {
         string memory p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,string,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
     }
 
     function log(
@@ -530,9 +476,7 @@ library console {
         string memory p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
     }
 
     function log(
@@ -540,9 +484,7 @@ library console {
         string memory p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,string,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
     }
 
     function log(
@@ -550,9 +492,7 @@ library console {
         bool p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
     }
 
     function log(
@@ -560,9 +500,7 @@ library console {
         bool p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
     }
 
     function log(
@@ -570,9 +508,7 @@ library console {
         bool p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
     }
 
     function log(
@@ -580,9 +516,7 @@ library console {
         bool p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
     }
 
     function log(
@@ -590,9 +524,7 @@ library console {
         address p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
     }
 
     function log(
@@ -600,9 +532,7 @@ library console {
         address p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,address,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
     }
 
     function log(
@@ -610,9 +540,7 @@ library console {
         address p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
     }
 
     function log(
@@ -620,9 +548,7 @@ library console {
         address p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(string,address,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
     }
 
     function log(
@@ -630,9 +556,7 @@ library console {
         uint256 p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
     }
 
     function log(
@@ -640,9 +564,7 @@ library console {
         uint256 p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
     }
 
     function log(
@@ -650,9 +572,7 @@ library console {
         uint256 p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
     }
 
     function log(
@@ -660,9 +580,7 @@ library console {
         uint256 p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
     }
 
     function log(
@@ -670,9 +588,7 @@ library console {
         string memory p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
     }
 
     function log(
@@ -680,9 +596,7 @@ library console {
         string memory p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
     }
 
     function log(
@@ -690,9 +604,7 @@ library console {
         string memory p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
     }
 
     function log(
@@ -700,9 +612,7 @@ library console {
         string memory p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
     }
 
     function log(
@@ -710,9 +620,7 @@ library console {
         bool p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
     }
 
     function log(
@@ -720,9 +628,7 @@ library console {
         bool p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
     }
 
     function log(
@@ -730,9 +636,7 @@ library console {
         bool p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
     }
 
     function log(
@@ -740,9 +644,7 @@ library console {
         bool p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
     }
 
     function log(
@@ -750,9 +652,7 @@ library console {
         address p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
     }
 
     function log(
@@ -760,9 +660,7 @@ library console {
         address p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
     }
 
     function log(
@@ -770,9 +668,7 @@ library console {
         address p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
     }
 
     function log(
@@ -780,9 +676,7 @@ library console {
         address p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
     }
 
     function log(
@@ -790,9 +684,7 @@ library console {
         uint256 p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
     }
 
     function log(
@@ -800,9 +692,7 @@ library console {
         uint256 p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
     }
 
     function log(
@@ -810,9 +700,7 @@ library console {
         uint256 p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
     }
 
     function log(
@@ -820,9 +708,7 @@ library console {
         uint256 p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
     }
 
     function log(
@@ -830,9 +716,7 @@ library console {
         string memory p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
     }
 
     function log(
@@ -840,9 +724,7 @@ library console {
         string memory p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,string,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
     }
 
     function log(
@@ -850,9 +732,7 @@ library console {
         string memory p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
     }
 
     function log(
@@ -860,9 +740,7 @@ library console {
         string memory p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,string,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
     }
 
     function log(
@@ -870,9 +748,7 @@ library console {
         bool p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
     }
 
     function log(
@@ -880,9 +756,7 @@ library console {
         bool p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
     }
 
     function log(
@@ -890,9 +764,7 @@ library console {
         bool p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
     }
 
     function log(
@@ -900,9 +772,7 @@ library console {
         bool p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
     }
 
     function log(
@@ -910,9 +780,7 @@ library console {
         address p1,
         uint256 p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
     }
 
     function log(
@@ -920,9 +788,7 @@ library console {
         address p1,
         string memory p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,address,string)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
     }
 
     function log(
@@ -930,9 +796,7 @@ library console {
         address p1,
         bool p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
     }
 
     function log(
@@ -940,9 +804,7 @@ library console {
         address p1,
         address p2
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(address,address,address)", p0, p1, p2)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
     }
 
     function log(
@@ -951,9 +813,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -962,15 +822,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -979,9 +831,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -990,15 +840,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1007,15 +849,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1024,15 +858,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1041,15 +867,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1058,15 +876,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1075,9 +885,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1086,15 +894,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1103,9 +903,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1114,15 +912,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1131,15 +921,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1148,15 +930,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1165,15 +939,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1182,15 +948,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,uint,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1199,15 +957,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1216,15 +966,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1233,15 +975,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1250,15 +984,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1267,15 +993,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1284,15 +1002,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1301,15 +1011,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1318,15 +1020,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1335,15 +1029,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1352,15 +1038,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1369,15 +1047,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1386,15 +1056,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1403,15 +1065,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1420,15 +1074,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1437,15 +1083,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1454,15 +1092,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,string,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1471,9 +1101,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1482,15 +1110,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1499,9 +1119,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1510,15 +1128,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1527,15 +1137,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1544,15 +1146,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1561,15 +1155,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1578,15 +1164,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1595,9 +1173,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1606,15 +1182,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1623,9 +1191,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1634,15 +1200,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1651,15 +1209,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1668,15 +1218,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1685,15 +1227,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1702,15 +1236,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,bool,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1719,15 +1245,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1736,15 +1254,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1753,15 +1263,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1770,15 +1272,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1787,15 +1281,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1804,15 +1290,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1821,15 +1299,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1838,15 +1308,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1855,15 +1317,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1872,15 +1326,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1889,15 +1335,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1906,15 +1344,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1923,15 +1353,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1940,15 +1362,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1957,15 +1371,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1974,15 +1380,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(uint,address,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -1991,15 +1389,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2008,15 +1398,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2025,15 +1407,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2042,15 +1416,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2059,15 +1425,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2076,15 +1434,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2093,15 +1443,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2110,15 +1452,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2127,15 +1461,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2144,15 +1470,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2161,15 +1479,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2178,15 +1488,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2195,15 +1497,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2212,15 +1506,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2229,15 +1515,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2246,15 +1524,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,uint,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2263,15 +1533,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2280,15 +1542,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2297,15 +1551,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2314,15 +1560,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2331,15 +1569,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2348,15 +1578,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2365,15 +1587,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2382,15 +1596,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2399,15 +1605,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2416,15 +1614,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2433,15 +1623,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2450,15 +1632,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2467,15 +1641,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2484,15 +1650,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2501,15 +1659,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2518,15 +1668,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,string,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2535,15 +1677,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2552,15 +1686,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2569,15 +1695,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2586,15 +1704,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2603,15 +1713,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2620,15 +1722,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2637,15 +1731,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2654,15 +1740,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2671,15 +1749,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2688,15 +1758,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2705,15 +1767,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2722,15 +1776,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2739,15 +1785,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2756,15 +1794,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2773,15 +1803,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2790,15 +1812,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,bool,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2807,15 +1821,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2824,15 +1830,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2841,15 +1839,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2858,15 +1848,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2875,15 +1857,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2892,15 +1866,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2909,15 +1875,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2926,15 +1884,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2943,15 +1893,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2960,15 +1902,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2977,15 +1911,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -2994,15 +1920,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3011,15 +1929,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3028,15 +1938,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3045,15 +1947,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3062,15 +1956,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(string,address,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3079,9 +1965,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3090,15 +1974,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3107,9 +1983,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3118,15 +1992,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3135,15 +2001,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3152,15 +2010,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3169,15 +2019,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3186,15 +2028,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3203,9 +2037,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3214,15 +2046,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3231,9 +2055,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3242,15 +2064,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3259,15 +2073,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3276,15 +2082,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3293,15 +2091,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3310,15 +2100,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,uint,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3327,15 +2109,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3344,15 +2118,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3361,15 +2127,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3378,15 +2136,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3395,15 +2145,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3412,15 +2154,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3429,15 +2163,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3446,15 +2172,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3463,15 +2181,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3480,15 +2190,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3497,15 +2199,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3514,15 +2208,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3531,15 +2217,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3548,15 +2226,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3565,15 +2235,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3582,15 +2244,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,string,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3599,9 +2253,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3610,15 +2262,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3627,9 +2271,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3638,15 +2280,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3655,15 +2289,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3672,15 +2298,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3689,15 +2307,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3706,15 +2316,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3723,9 +2325,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3734,15 +2334,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3751,9 +2343,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3)
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3762,15 +2352,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3779,15 +2361,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3796,15 +2370,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3813,15 +2379,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3830,15 +2388,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,bool,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3847,15 +2397,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3864,15 +2406,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3881,15 +2415,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3898,15 +2424,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3915,15 +2433,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3932,15 +2442,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3949,15 +2451,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3966,15 +2460,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -3983,15 +2469,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4000,15 +2478,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4017,15 +2487,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4034,15 +2496,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4051,15 +2505,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4068,15 +2514,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4085,15 +2523,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4102,15 +2532,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(bool,address,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4119,15 +2541,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4136,15 +2550,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4153,15 +2559,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4170,15 +2568,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4187,15 +2577,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4204,15 +2586,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4221,15 +2595,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4238,15 +2604,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4255,15 +2613,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4272,15 +2622,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4289,15 +2631,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4306,15 +2640,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4323,15 +2649,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4340,15 +2658,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4357,15 +2667,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4374,15 +2676,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,uint,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4391,15 +2685,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4408,15 +2694,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4425,15 +2703,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4442,15 +2712,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4459,15 +2721,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4476,15 +2730,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4493,15 +2739,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4510,15 +2748,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4527,15 +2757,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4544,15 +2766,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4561,15 +2775,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4578,15 +2784,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4595,15 +2793,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4612,15 +2802,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4629,15 +2811,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4646,15 +2820,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,string,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4663,15 +2829,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4680,15 +2838,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4697,15 +2847,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4714,15 +2856,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4731,15 +2865,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4748,15 +2874,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4765,15 +2883,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4782,15 +2892,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4799,15 +2901,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4816,15 +2910,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4833,15 +2919,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4850,15 +2928,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4867,15 +2937,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4884,15 +2946,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4901,15 +2955,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4918,15 +2964,7 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,bool,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4935,15 +2973,7 @@ library console {
         uint256 p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,uint,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4952,15 +2982,7 @@ library console {
         uint256 p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,uint,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4969,15 +2991,7 @@ library console {
         uint256 p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,uint,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -4986,15 +3000,7 @@ library console {
         uint256 p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,uint,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5003,15 +3009,7 @@ library console {
         string memory p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,string,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5020,15 +3018,7 @@ library console {
         string memory p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,string,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5037,15 +3027,7 @@ library console {
         string memory p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,string,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5054,15 +3036,7 @@ library console {
         string memory p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,string,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5071,15 +3045,7 @@ library console {
         bool p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,bool,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5088,15 +3054,7 @@ library console {
         bool p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,bool,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5105,15 +3063,7 @@ library console {
         bool p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,bool,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5122,15 +3072,7 @@ library console {
         bool p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,bool,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5139,15 +3081,7 @@ library console {
         address p2,
         uint256 p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,address,uint)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5156,15 +3090,7 @@ library console {
         address p2,
         string memory p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,address,string)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5173,15 +3099,7 @@ library console {
         address p2,
         bool p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,address,bool)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
     }
 
     function log(
@@ -5190,14 +3108,6 @@ library console {
         address p2,
         address p3
     ) internal view {
-        _sendLogPayload(
-            abi.encodeWithSignature(
-                "log(address,address,address,address)",
-                p0,
-                p1,
-                p2,
-                p3
-            )
-        );
-    }
-}
\ No newline at end of file
+        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
+    }
+}
diff --git a/forge/src/test/utils/Utilities.sol b/forge/src/test/utils/Utilities.sol
index 18c0ed9..737b3cf 100644
--- a/forge/src/test/utils/Utilities.sol
+++ b/forge/src/test/utils/Utilities.sol
@@ -17,10 +17,7 @@ contract Utilities is DSTest {
     }
 
     //create users with 100 ether balance
-    function createUsers(uint256 userNum)
-        external
-        returns (address payable[] memory)
-    {
+    function createUsers(uint256 userNum) external returns (address payable[] memory) {
         address payable[] memory users = new address payable[](userNum);
         for (uint256 i = 0; i < userNum; i++) {
             address payable user = this.getNextUserAddress();
@@ -35,4 +32,4 @@ contract Utilities is DSTest {
         uint256 targetBlock = block.number + numBlocks;
         vm.roll(targetBlock);
     }
-}
\ No newline at end of file
+}
diff --git a/forge/src/test/vUSDC.t.sol b/forge/src/test/vUSDC.t.sol
index b422e04..35a53f0 100644
--- a/forge/src/test/vUSDC.t.sol
+++ b/forge/src/test/vUSDC.t.sol
@@ -1,27 +1,23 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.10;
-
+// disregard import failures
 import "ds-test/test.sol";
 import {vUSDC} from "../vUSDC.sol";
 import "../utils/ERC20TokenFaker.sol";
 import "../utils/FakeERC20.sol";
 import "./utils/Utilities.sol";
-
 import {ERC20, ERC4626} from "solmate/mixins/ERC4626.sol";
 import "openzeppelin/utils/Strings.sol";
 import {IStargate} from "../interfaces/IStargate.sol";
 
-// interface Vm {
-//     function warp(uint256 x) external;
-
-//     function expectRevert(bytes calldata) external;
-
-//     function roll(uint256) external;
-
-//     function prank(address) external;
-// }
+/// @title A Test for vUSDC
+/// @author koda
+/// @notice This test relies on FakeERC20.sol to test USDC deposits and staking
+/// @notice Utilities.sol provides some useful functions for creating users
+/// @notice VM is the cheatcode reference. eg. vm.warp(1 days) warps timestamp forward 1 day
+/// @dev Some tests require changes to origional contact (eg. LPTest)
 
-contract vUSDCtest is DSTest, ERC20TokenFaker{
+contract vUSDCtest is DSTest, ERC20TokenFaker {
     vUSDC vusd;
     FakeERC20 fakeUSDC;
     ERC20 UNDERLYING;
@@ -29,6 +25,7 @@ contract vUSDCtest is DSTest, ERC20TokenFaker{
     Utilities internal utils;
     address payable[] internal users;
     Vm internal immutable vm = Vm(HEVM_ADDRESS);
+
     // Vm constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
 
     function setUp() public {
@@ -68,8 +65,8 @@ contract vUSDCtest is DSTest, ERC20TokenFaker{
         vusd.deposit(1000000000, address(this));
         utils = new Utilities();
         users = utils.createUsers(5);
-
     }
+
     function setFeeFail() public {
         address payable alice = users[0];
         vm.prank(alice);
@@ -81,6 +78,7 @@ contract vUSDCtest is DSTest, ERC20TokenFaker{
     function testInitialBalance() public {
         assertEq(1000000000, vusd.balanceOf(address(this)));
     }
+
     function testUserDeposit() public {
         address payable alice = users[0];
         vm.label(alice, "Alice");
@@ -89,7 +87,6 @@ contract vUSDCtest is DSTest, ERC20TokenFaker{
         assert(vusd.balanceOf(alice) > 1);
     }
 
-
     // // test whole deposit flow
     function testDeposit() public {
         uint256 bal = vusd.balanceOf(address(this));
diff --git a/forge/src/vUSDC.sol b/forge/src/vUSDC.sol
index decd354..5485299 100644
--- a/forge/src/vUSDC.sol
+++ b/forge/src/vUSDC.sol
@@ -10,7 +10,11 @@ import {IRouter} from "./interfaces/IRouter.sol";
 import {IAsset, IBalancer} from "./interfaces/IBalancer.sol";
 import {IERC20} from "openzeppelin/token/ERC20/IERC20.sol";
 
-// Vault for depositing underlying (usdc) into stargate, compounding STG rewards through balancer for more underlying
+/// @title Vault for USDC stargate staking and compounding for more USDC
+/// @author koda
+/// @notice This contract is initialised with variables for the Arbitrum network
+/// @notice This contract passes all tests on ETH mainnet when substitued with mainnet variables
+/// @dev Gas optimisation is not implemented
 contract vUSDC is ERC4626, Ownable {
     using FixedPointMathLib for uint256;
     event balancerSwap(uint256 _amt);

From 7fdef5a3c9fec45872e51bb8c7125ed45f448987 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 8 Apr 2022 15:54:37 +1000
Subject: [PATCH 12/45] long vault target calc changes

---
 forge/src/longVault.sol | 42 ++++++++++++++++++++++++++++-------------
 1 file changed, 29 insertions(+), 13 deletions(-)

diff --git a/forge/src/longVault.sol b/forge/src/longVault.sol
index 6a20cc2..1eaeb2b 100644
--- a/forge/src/longVault.sol
+++ b/forge/src/longVault.sol
@@ -5,8 +5,10 @@ import {L2Encoder} from "./utils/L2Encoder.sol";
 import {IPoolCommitter} from "./interfaces/IPoolCommitter.sol";
 import {ILeveragedPool} from "./interfaces/ILeveragedPool.sol";
 import {ERC20} from "../lib/solmate/src/tokens/ERC20.sol";
+import {SafeMath} from "openzeppelin/utils/math/SafeMath.sol";
 
 contract longVault {
+    using SafeMath for uint256;
     ERC20 USDC;
     ERC20 THREELBTC;
     IPoolCommitter poolCommitter;
@@ -41,9 +43,8 @@ contract longVault {
 
     function checkSkew() public onlyPlayer {
         uint256 _skew = skew();
-        uint256 _bal = THREELBTC.balanceOf(address(this)); //todo  add aggregate balance
+        uint256 _bal = THREELBTC.balanceOf(address(this)).add(agBal());
         if (_skew > threshold) {
-            // TODO: and skew impact
             uint256 target = target();
 
             if (_bal < target) {
@@ -72,41 +73,56 @@ contract longVault {
     }
 
     function target() public view returns (uint256) {
-        //todo and add aggregate Balance
-        uint256 _bal = THREELBTC.balanceOf(address(this));
-        uint256 _skew = _bal / skew();
-        uint256 target = _skew - pool.longBalance();
+        uint256 _bal = THREELBTC.balanceOf(address(this)).add(agBal());
+        uint256 _skew = skew();
+        uint256 _target = pool.longBalance() / threshold;
+        uint256 target = _target.sub(pool.shortBalance());
         return target;
     }
 
     function acquiring() public view returns (uint256) {
-        uint256 _bal = THREELBTC.balanceOf(address(this));
-        return target() - _bal;
+        uint256 _bal = THREELBTC.balanceOf(address(this)).add(agBal());
+        return target().sub(_bal);
     }
 
     function disposing() public view returns (uint256) {
-        uint256 _bal = THREELBTC.balanceOf(address(this));
-        return _bal - target();
+        uint256 _bal = THREELBTC.balanceOf(address(this)).add(agBal());
+        return _bal.sub(target());
     }
 
     function acquire(uint256 _amount) private {
-        bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongMint, agBal(_amount), true);
+        bytes32 args = encoder.encodeCommitParams(
+            _amount,
+            IPoolCommitter.CommitType.LongMint,
+            agBalBool(_amount),
+            true
+        );
         poolCommitter.commit(args);
         emit acquired(_amount);
         tradeLive = true;
     }
 
     function dispose(uint256 _amount) private {
-        bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongBurn, agBal(_amount), true);
+        bytes32 args = encoder.encodeCommitParams(
+            _amount,
+            IPoolCommitter.CommitType.LongBurn,
+            agBalBool(_amount),
+            true
+        );
         poolCommitter.commit(args);
         tradeLive = false;
     }
 
-    function agBal(uint256 _amt) public view returns (bool) {
+    function agBalBool(uint256 _amt) public view returns (bool) {
         uint256 lTokens = poolCommitter.getAggregateBalance(address(this)).longTokens;
         lTokens > _amt ? true : false;
     }
 
+    function agBal() public view returns (uint256) {
+        uint256 lTokens = poolCommitter.getAggregateBalance(address(this)).longTokens;
+        return lTokens;
+    }
+
     modifier onlyPlayer() {
         require(vault.balanceOf(address(msg.sender)) > 1, "Only player can execute");
         _;

From 1eb70f6f7968a56f824ffd051354b1963e8213d4 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 13:33:00 +1000
Subject: [PATCH 13/45] delete old files

---
 forge/foundry.toml                      |    7 -
 forge/gas-report.png                    |  Bin 106863 -> 0 bytes
 forge/lib/abdk-libraries-solidity       |    1 -
 forge/lib/ds-test                       |    1 -
 forge/lib/forge-std                     |    1 -
 forge/lib/openzeppelin-contracts        |    1 -
 forge/lib/perpetual-pools-contracts     |    1 -
 forge/lib/solmate                       |    1 -
 forge/readme.md                         |   39 -
 forge/remappings.txt                    |    9 -
 forge/src/interfaces/IBalancer.sol      |   50 -
 forge/src/interfaces/ILeveragedPool.sol |  215 --
 forge/src/interfaces/IPoolCommitter.sol |  211 --
 forge/src/interfaces/IRouter.sol        |   16 -
 forge/src/interfaces/IStargate.sol      |   15 -
 forge/src/longVault.sol                 |  130 -
 forge/src/test/utils/Console.sol        | 3113 -----------------------
 forge/src/test/utils/Utilities.sol      |   35 -
 forge/src/test/vUSDC.t.sol              |  151 --
 forge/src/utils/ERC20TokenFaker.sol     |   39 -
 forge/src/utils/FakeERC20.sol           |  225 --
 forge/src/utils/IVm.sol                 |   99 -
 forge/src/utils/L2Encoder.sol           |   57 -
 forge/src/vUSDC.sol                     |  155 --
 lib/openzeppelin-contracts              |    1 +
 lib/solmate                             |    2 +-
 26 files changed, 2 insertions(+), 4573 deletions(-)
 delete mode 100644 forge/foundry.toml
 delete mode 100644 forge/gas-report.png
 delete mode 160000 forge/lib/abdk-libraries-solidity
 delete mode 160000 forge/lib/ds-test
 delete mode 160000 forge/lib/forge-std
 delete mode 160000 forge/lib/openzeppelin-contracts
 delete mode 160000 forge/lib/perpetual-pools-contracts
 delete mode 160000 forge/lib/solmate
 delete mode 100644 forge/readme.md
 delete mode 100644 forge/remappings.txt
 delete mode 100644 forge/src/interfaces/IBalancer.sol
 delete mode 100644 forge/src/interfaces/ILeveragedPool.sol
 delete mode 100644 forge/src/interfaces/IPoolCommitter.sol
 delete mode 100644 forge/src/interfaces/IRouter.sol
 delete mode 100644 forge/src/interfaces/IStargate.sol
 delete mode 100644 forge/src/longVault.sol
 delete mode 100644 forge/src/test/utils/Console.sol
 delete mode 100644 forge/src/test/utils/Utilities.sol
 delete mode 100644 forge/src/test/vUSDC.t.sol
 delete mode 100644 forge/src/utils/ERC20TokenFaker.sol
 delete mode 100644 forge/src/utils/FakeERC20.sol
 delete mode 100644 forge/src/utils/IVm.sol
 delete mode 100644 forge/src/utils/L2Encoder.sol
 delete mode 100644 forge/src/vUSDC.sol
 create mode 160000 lib/openzeppelin-contracts

diff --git a/forge/foundry.toml b/forge/foundry.toml
deleted file mode 100644
index 19903e0..0000000
--- a/forge/foundry.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[default]
-src = 'src'
-out = 'out'
-libs = ['lib']
-remappings = ['ds-test/=lib/ds-test/src/']
-
-# See more config options https://github.com/gakonst/foundry/tree/master/config
\ No newline at end of file
diff --git a/forge/gas-report.png b/forge/gas-report.png
deleted file mode 100644
index 0ccd61e90df2cc3f07b1c11e607e07447126e01d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 106863
zcmZU)19T-p&@h@C+qP{xH@3a8t&MGOoNR1uHnwfsHa0dlfA;fvZ~Dxcn(k6pchBvr
zt{bVOAc+8r3kw1Qf*>s=rUC*2iV6Y(@P>x`stIQ_t^omoU9b`rRgxAJC06?GU~Xk=
z1_B}#nUV^nmb8i*aP?Wr^-ZJ*%?qsv4JZT65D?^ooDvU?DgzB8JWxenwew90Mc7On
ziw3r;Dxd<Q*3d}Vc7<!CAg?MK0+03$EUu>gs^e)Y)0y(ljMe>eLf|Qf4G^$5og&3*
z!~s$_&^k9lEF|G0LJIZ-o(F)84?uC;yER4C5EH`&nvVU|+uDSjY3VfL%lWhI|5;to
zi#6f_0+fa>y*BHh4_Qa??Msq!1^^dH{gMV-6P+$a(kR7Y#k5$atdic{vQ#OtV{#)R
zV@=5_pg?ja4rS&+h;>N)BnX)hMnw@NR`e&ZB2lI!S2C#%Zc*&TJ<K&U9=SimYA8^d
z00ANrY3aAASyukzxdju`hb1(gb=5GvZ_%cSa+ispcb0#fP0hwiADJbS>60NPNi`sN
zy7_Qc^JOqgClGRtQT$2$f<kY1(rAuGS0Ys>j$gxRm(8aTGWXP!i6zsiQqcqkLA8Mk
z=(6=>Dc;30s}(dyGNn%`76a5DA^^$sZXh-R*Pv&?N~<dUcm!;AtP$OZif2)sUm*90
zgV#3D>`J??`<`x(die;pFgT^tx%3ZKg!Vj-+0EG6Gw5f)X&Sa!2l=vMYbrUL2oBQ-
zyvnPYr}9{1>&Ri2K3+b5zl*)p0D3U>4s@0<xg!K4NNav;(EG*><;rRzg^F?pb84@M
zenvnq%H6p+EB*xm0RY>-IZ1POGCT4KdiG|%3qwk8Ya|<juf%sY7=)d;bFQw`mvRwg
zCKM#AZfCUEGfD9N8440PkTwrsX9yw}Kv5%3>jII}g9RRdjEq<y45|g~0fep#K&OWs
z@3B?_m+3LDAy5mTtwCA{65WBe1W@(hI0AG5%RLN^MASVX9*AMRe9W-IU$j6qDLmGY
z31Ykv6l0MsB@lE-aS<3L)?~;?5}pS5Z*VEVVkL+Mtlz<YA+e$sd9q4KE?8&5VR_3l
zRM-$nMz|G7nf>*KloLUsyOth+EXd;?2uG3*6vpuK-C##HAIL7y?I4V6XAf`)C318E
zvyeJ*7G+yCZd#O-sKf$|yeMU}U)E}5zY!KA+X7Yc^z#G@YAtCq0-MCW3xa1^ED3p`
zIzc-DdVy8qT!qv54tZ}g{U_Dfuo6fn!8bjQ%r|N56UK5VCGe`jJYhU>t)VzQ9sS0&
zE)@_<2zWo_drC}FjkyfnO)_gPRtRl{+`z;8t@dpl^;;bAu~MVy`Yr|t2C|3rh7ooI
zcceW;JIDl)b0e_!mv_dmAD&g8|2&sID+l5B{@4+Qrn-iah0cV2gRu)K4*~R1D`#5@
z-;+w9%}16;9u7$CdG3Mj;h{#F%6+GrB#V?PmpUx!FN!V_oRh4BT+NuEq)IqEh&cc|
zaJ$vJ#e)qsR=6o9SNTqZN8_4YpDdY-M5~6uhY<^FU{)+sEK@(`nv(h(T%Aq*=b6YN
z=pyT4;crcKgI_2M6N@X>x{VmtDb~Y_UW*b7WoL+IyJy;Gcng0PnaYr?ci1O5K-r&h
zLvi2Or>yT)mDSK_Gsg<6iZ4rZN)cyj*x_))e=5-B6BM}4hjDPQXLFcv+;PxxC|c8=
zP`B}9i%u6g6cFWam-uJo3k7qCGMjw-7{Xb$=vbaxyj?`K#IWJ8+MIhWnw&wLnVQ)u
z*ev)^f~qvBWK*=Log&P><7INOYRhTk-!$GNYkRsk6tL-(>MZtpyKlRfxJS4TzNdKQ
zdze1!X3oQV#x26LW#cwuHkIPI=S0V`XXCef{*gaw$ij+q_`~^!5t%@tAzACJexZG#
zvI*Qi_CCju{1B3S1f^V(T9O?l0cC$lSc$V-YC31y78_X_%VdZ--vsaER;EtcaC$YH
z0}D~ZOx=zax)!?@e@&6rtJaa0hR#+)-#3;@)(STrz51|9y^7GKlqF3&Lp)8qgh~6%
zob<HxOSVC_a*M~cL_6&!&nAQ>UpJR_=5`J@1~(>)^eLIFMl+4$it0zk$Mnayiz_}$
z?hx(@Crf9K3(JcU=L(mOQ!yu4mv5&FXZK^PL)tqX!!NOLi)OLoys3z(OjY((D$5ef
zBwVV^rp<cxopQKrL9KzFvjqE>$6a$DA#ajMnsK^uWQ6`6YhLCaOWuf6O=%2io&Ij!
zskK<kHr1(pnY-ENADzv8!z1B;R4?vUmIqR=boSqp%?4#G2uwTg>z|Td3GTe79}Sr-
zn%@fFgWsb++QHaCjX`Na2_bNyN+3AF5usYa84#?IhQPxi9bhgGPn<onc&8jAbVhFD
zo%0W7e$7P93>z&O&DAvVTxZ4e=p6H>*>Gy|H&ft;IQKP&3H_*v7>RuLBy`gs=os@<
zBqbnC6?c<RF2odHl<bUtjNU@`6&hldAe=`j$IV37!Fm&%5~^ZXKoO$z^L$SM&jwc(
zu_0w-;jE=}GWF|uzqo@+)J=>^v}dZ(itpZ;6Uh!uhf`!!(HqcnVaG|rPu0zRPsf|8
zJc=!HRB<bYzgy`b=s5N<_{;e>zDHJx)+6IA<y!`C+EGdqhn>_389iDTa;-Q<f#zxN
zsru;^TOS*u=?}9ZGfuPJ`o#L!XpRA#J?B-()t6NPR6OYfv4s7EdI1Y9T-wS6;W~)A
zC0$%rV%JfI!|jo`+m1WhJ3;zbJs)-h0fVgV#sRO<R|-WqP&hxWDE%>=wb}{G)iX2S
zaqaP^ssN3miW4oXx;n?hp5J-ujpdQ$Y#N_+Lw@q78O=8POHCMOSXH#=pOhz=VWcUf
zR?1hr)2`~<1>G3F>z!LxA5#wo(JzCkvgfj6GJ*~}b}jGO{qBd`F?MpBE1jdR^Es0%
zlY5iR&Cj-F4C+h_)EC>l7B+XBLrr^j4$Vw!eq|G_71mHr;XdI7{1qLprKeMqd_tPg
zboT16>YNvI>y3WPZ=3I%%TLdjRuyyAv}LdNohNU6-ocNYnwgrZ7yXyx>rbZs=YOY&
z(u5WkPZp9Fe0Ycj^M1ut2xuN_Xlhn#c9#L{<GJ7o<aj+U;y?43B-V#I<?l-p`*&*I
zuj`4D{5yQf@1=&7k7kE*C;Zl2e|S~2;8^R=@o$jYDmPFzJmMqqY|S36x}96J=OSe>
z^D29)+#Qst4ycBf4k=(|5n81-baN-Um2{gZ4}a9(SUBWlx>vpVoV-M1fih)Xn7Zb4
zow(i%P{hd&GqEu>>pFGLZ5+<Io@1pN#JaY-aT&O_uX#;=eAAge&rx0Wt;%iP_22K4
zpPHm=KH55KC2)RIa8Rk<L;RfD*_>#vzC7H->+C)Q90}iuHinzU-4m*RT0ht%^{G46
zO?OxSaa!1a`{?+4+&${|#;^1oa$9s>wmaV@Jlu;W8YsG)GwIKHt$XWpFFt#9)_vt=
z^>SM(<nwug8%sp!LE+2s=+%#R!3DL&+kJr@iS2pM_-FIvZ4YUU$XbY1$jvY6?cT-Z
z#$x06mPx~4tt-sWm-#0LC*`h8D_S84tTHzTM!+&ud@DBq<ctF(;*RS03?`8B6HX5K
zS&^T|TQPzT<YB*lgcgK5LW9IQ%BS=N6gkkcfhiz6EBTcvp_rFP;fS=6xKMg^Wd+aF
zen1;=UF>da+hAsUE{mXYE&#H&EkAX)k7^DVkO9LNi{n_`?1b?gE;se+e|nRPNlo{h
z`GICag2|$4lDzx1&DAi|k~Wu@2ci9fp+NxQRv_SC5a8>^{klOwz!JkipuV188)Fc$
zJkbAc1x3vR`)?TF{SQ%CRa9E~>#1t;-OSA1+0wz~d(g)87po;JH7yq{c{yGa2RlY1
zQwL)+Mh`p3e<UFM9=u<motcXfv4@?ly)&<e0O@~V@P5Jns+mZM{{zLvMu1dHUWr)L
z;ky|zCnGZ>GpQgfF)=a!cT;m-6)}nbBL8|5AhmRHapYxUa(8!UbZ299_-?_(!o$PE
z#LUXX%F6JC!Qkv^?_%V^VDC)!pG^LnkC>UW$#*M97b^#Q;(vUNj2&EE1V~B$3HqPw
zKlL>8u=-y~_Rjy+t*;I;{cB-jVPt0dAKqW2{Qqism8?9>Y_-L#?7qzNB}0&ni--R|
z@c(};|10tTP-^`zB?lYx|E2stE&pFib!W5hq7HUnB3%UkcVzyH`2RNk7a>2>zn=de
zOZ=yq|D*QH&VsP~O#d@xg0Mnw*uOwPfFROh!fGCXa{;I{{Kmzr*O%Aq@m0Ym#39a-
z^es6S?0H!cY3LArJ8S4sBoY!JHB2WtISC0s1jHm0lNZuNt{(8THNM)lHU62yo-sRN
zX>Q?eQ7!Xy5qsa3!#<}Y&6djUv(ut6Bkc|J&ims<9H}|k;?m+(2at*rA*j-85Ed5b
z;d5BgYtg%0hL-7^85PzmK5c;dS5S8WoZOx<N|8#x%&d_@_5iR1-)`c%+JRB~gbRUU
zSeE{J5ElRgB<w<6Ny2kWcv)kEE{<8Li$KIZfFGCZfj6zK<jWuqZ#?w+`nR0NfJfj2
zp<!?eBDL{juDLB7l1uM(FOv)~RRS1{NWNCEZAGvKc5wkPIsXGMnujBqmj39Lvs5iW
z%y0NLox{APwFss;RFH-1T!~TQ!a1rRfflzwD!dmL{MmF~P0i*M`<$lsz#zG;e9sNZ
zbfmEo!9|U^F9k0G8Lt4ih{1@+1id)t=ioR&Va=OLTPW65b|=_`JDmzo0#{2jbf{Zh
zv)C7bRmXu-{J6&VCXg6<)n+a+yhTuL9>}|Q(S1;d)-;`@yWb-rEs<QDkakv9WRkxB
zTD(ufw7>5Qg841_>(Rz&4NL*)ny}<8eV*y^`wozlt{m$9<ekm%%6CZE%PT`CG0YO_
ze~XJX5<5G4U!Ox)FxKA})`f)y$ltOmGh90Qo|}U;X7ikBY<~zWe>p&t>!P{ZBk{kS
z2Rpuqv+=r9G(2n(UTdXz>@gwrVPHX7xp%8WJ2c{>&0X<}%1O=T@jZF!xz8SZI>44I
zinpPuJ$qczr|?ruh)R1&@Mf`Jc$_SEV-xy6Ps?afG0)&c&YDO7uLL`H7E>+$5ci!5
z>n#zUR1ijZ7yXb77^cRoWRiyW6G_CZbd%pc<e%vbhPIxP(53cxIMlYCA`&n+&BH`Q
zmx9M*0q-(s;f@E&7YXDE%tZ1dE7BvobHq>++w)Kd1i=u<hwP5p(-(dOM?AW9`M~*x
zI}1*J2&?1)3lyCkR+{W2kv%gc{>@Z0&j5t%3tYMQ`aU>n>a=*MeuV|}wFShTK(}rT
z-T<T!n02SAtIg78>Q~*Qpw9T;Ee;O9sLStBij>#D*1$IB!Hf_)NkTz*(@t{qSdPBk
z3F4b8#;zte8Q!-{X6@YG!sfMZ3prH*=}>uiR%@*GG5tMp%l|1&BhUjm<Ax`m9c5+s
z9np%V1w%Z9oCfkRqxjCFXZ4de?l7{+g>CAE{mGl^4`npA6nQCmy(G}>a^sLe(d6H{
z;cbN4gQMKT`C-*Y<yQ(HG@SlJiWFSh3AbRCuLQ~?*ZHyIv4LaPmjf1p{djqAKNlTr
zCFyMl_Ws$z-H(3c5~w#vc(O)lxG#qu9CH|xmIm*3ti))_v-`6t?Rz3O4PFxU<ie^z
zk2g^A4^+W1)kHfX?1mxYjSu=p?+!c%s(Cl&#tXmW9L=!1U}58+lQ(gbn<m02I2w^q
zJ$_+gEAMW|+bDDZnbTBUFhf%tUx>?`@lzS!Rr&Y0Y`3vwg*EF)X1+e(QlR??khIXB
zvglCq^KqhRf&7Gp98TpsXm<@8O6821satMf@i@Eo21b6b>)B{6Wc=;SIr|_ImE|Fd
z%*;5mFxF>E5$h=8&1UPgdudzr7KN8e^RM>8>gcv`C%btZ_Z5V~yw5nOzOe49K-aj+
zuy<cLqYc$J;Nl$Y^W!@N^A1(8;f}Z{GxCnGn5sCKkLMUab($Ku$tBM4+4|fH=!4Fg
z;h+Pi=wS09{Lkc{;NBa2h*5~m3Tahs?l`tD(?iTY=#4*=-7jHQ3!Qhv%ew=^<_5YU
z8Y&;eFOVl^V)%)}ELqf}zmsD{C@biic?H4nfHIA->fL)%B6NT2N5Sd@WE92-%ve7b
zacbZzXP>O1z?hI+qg)1mx49*@PsNBN-=AcW7U9E9%}R$4t|kPG3aA*aS4`I26<)+A
zX2Xu+NF`5HI+Qs;?wztw!wr3U3XRa8_R{k1EzO!E3kyrDYJ(L$$hq_7#}L1~p#vWy
z@HJAKl+vkv>n*xAF^_Br2qwTPHurP1e8Fcf&Yx>YdI9^gkbOL$r(~M(Lyj1)?asMZ
zudYvsq-}niCM`4thA_V3#v>g4`P<rHh8Kn9hU2n$Bydy<Fw>WCi{rFThxudk4SitV
z#_{ps9OdOkgW0m!1a`^|3!It!7|~-!HxF<|)sjzP9g(5TCw2KX@5|Bo)6yT<lZlz#
z!P!?1;YG>hQdikVx1MGybt;DU4#Oh7!U7~b4CxTW+Xn5(zcDp|y?;ZQU)@beDyhLT
zY;cV>(QFLwy19U~YYm@x;lPh2Ud#j2`^gXj2L}_k<Sed;)#Sv%&9>=oq<|&NfW;@K
zaJy=Uz&+L1{u(@qzDrL&5{D}vsjGAt^>IgzqYen>#{`)8ZUdD1U=6)7!EKmm3wmRr
zfsXTuT&<n*>GCb%-Pa@7v$862sx^VgBioE_69wbB)DS6cR649f{#|S?Kqxlo8aFm^
z1Ct8J@xvt^f3zFYWIlmRd?i{deI~~p16IX2NEX*mH5RTh1eQ@>C1d%Xq8KjKzw$UU
zVr$+qENF{w&w>@Yp@AU=v~S<JL@f};1EsI<VST4hkS5jTXVz@5Ko}kvYF>mgxi4mH
zvwqC8IPNU2Jh1q`QQpjm5z)l7+0g5Z=Jf<?uv)5<+gM^2?Y;b{#ja37o~<b)yin{1
zF+_)BjQDvb>4qxMnc6%Z`4Ipb<yBOvry0y?avxA;?@U0)b-uTb=W-eB;VsV?mP}ZN
z&8{xYdzP2X#h44hyl(C=v{MEXh4=@-SMh4vQQu8sZa8iK`3&<d%;~wbye`Vk!ae8X
zF}h$(urQW{0u^ExCnj-b0QNVv?Hy%tTl6A~!|$p{l#8tg>tViH1I?vyhJBld8L-GY
z&-N9u3_i{{Z3#5eVmr3xn(}2V2n4#zZ=emn!f4MC2Il}YgR~Gdhp6b{vWkRW%RWV>
zDbtrDTzKA$_qHfmc!i}-?CW*7E<+3UBZ3E(^PG0HD5ucipro;@@ttV2qdGPMF|F^t
z#Hvy@vUENyhpN<XLEQ$0$eJ87+pCb<`ZXZ9P0MU;gIx5+W{EVVua%A0FSA7b%NEn&
z)l+H1O3{ojxU}7L7UlQ|?H(VuLs-mNsoBC0qiuzw?wf%WxJ)iWYmRH#m*V2!$eRpf
zSq_kBuui(+GsWZ)zX5ho^3uBRq=j?aIRm>5-rh^V;!O7zsm&^zCB4HqY@@HmKhw-<
z$&m-DNnx3u^Yf}c%xr%Nh^AKEV~0?UCNDwfklBjUG`$Myt4J4^zZ_?H3~y;xST?q{
zMa)(7uy;&^>&~?^2KMQHdM}%csMo|PamKolfF3fV0c%I5#<Z`)IIym@6=A{T;iyvk
zD+ndkUmX(6AJTR)&>4)Kgn*%yGx;`;q*d}dt-{!-73ZFPnZ3SL?$Pfrh&j?I79DO`
zYniR<z_@}@beA;}`2-jWWc-MibU+K02^J-{&g2i(`U=s5Z1&!9PL3uKN1O~5?>sVZ
zpo`781lK^{%W=@O-{0@HTCkARvu+^rLG6MxW@ap><}njShv&-gG5`QU*2GEbD5aLy
zn(?^*%cJ<#*1IN;Ne>e*mvWGzpHjgcdd%}5J-Lp~*wg-<du+=ipdWG)0Np?y<6ToI
zJ7$FXXdO;WLI>+X!VxHpTx{FFC1DaB1n3MR4LdLxJ+*#nT37`uOmv1~6;iLR2vS7y
z*?w$@%*{@u{rNC=Tm<*+a?QI$xO3*?<iHJSX3`g546Q9~p;%ZZz=yk2i9A#~alk2}
zC*BcnPBt0!lAnyEXwDNQL6g-DkhgKEm&dCG;n%_{<^IRZ6{!{iY(pWxS}Oj9Z)+7m
z=C=sT<9&UBP+O_|Xogd+H%roKn43zu%SZGqrWbp?apTE+HdSlOQD`sAa4+~Xw|3=q
zj8f{VUlW@87x(o?|D?g?pWJW#2X?ugDFmkYzRUV8-<iQ#Url>TusHi(sWjO-ZsEMK
zvZF_ElAzu?xM5_rH)A;u`iHu!gXcc&!bvn^L3lyhj&mu2y#R6D>CE-yf~+2i4X@FY
zWw4<gvN8;VD|09Yy6)q0JcVzx%O<`wvpBHdVotqjh46X<1l{a&>r)cM%Hvp0nJxkY
z2=fBDd$jh*Vp=v;Hjs%>5YdyUe~=2BqXN;86(rOE#V`n*jk}h!Dk66Q_5?>Vv)ZC}
z<vPe^N}r}~^AZsG&WMY2&$}{@;C-Neu>m<@E3dzulu(iA=By#)k1}%%kX-Ss1O3Y8
z+bN<H_s~wKkecq?#dkcxWg5JII#e7s<wmoE1{qManw!n=ZoXrh0w>7io#6#AnmnY%
z6kNXHP^30EzBgqQ^fgv1vpu%jA3fiF_6jhlPe?lXwzi^<`8mC#lV2~^BsF%0XC+4Z
zfMr*wV8jk0UA<H&(uqwb0V1viRPtflthmiV=X99*Zm=j@ui)agnw<{VncKX4spXrs
z>%YD2XEIQmO~ly1hsaXN>*7RRl*-jyn%GbkK=Wr{u1L)^+ud)y#OIsazHO3mWWW7%
z5+xmtzk$(CAcnY?Dx|G^-&A?zHa+U0x9p*!%eaoGpm-e=yt<AfCYTnQc_TYHg-Wn&
zG`#e?iY)jeqxhY^%bsNBrv#?psB&C5!72_URxtsPsp<9hV4Ap+IlI%nz+M!A@bN%V
zccw6>VQ|jG5p%(=fH=JW6h72;Jc{opi0^?I6!S5`OD(+dOU!g7)GId{0qV!=#Pm%(
zO;-dQSD;n7q=KItYIdricG#2+(!e1AKjqX%#HSxY8`$4YB0e@`h9`|4mXIxn4e*Hl
zgZARVk-*CMO$8@NiGh?K$)lTzl%GIPI`L$5c3Ikyl0N>LEt2vNE<aM9%(;9#OBX^S
zrK#I5Rf-iT3AASCTgvZ=n)Sce!r64uv!AYI_1#`?27>3`!frgO?`|neHmyjp`eU<@
zRuz8*HC)#d)Cp=M6~+V1w>%~K#JJfKEgh^BN@DdC<l38EvrXWz+a)&FmzMW1i7PKq
zr5fy98=JHQ@*JwP1eRN0_}2-BEji`(p-GWQofbKTSwgk)m7vhKl42}2J87-NQ2L0r
z5<9_N@I4k>ueeL_emY(a&p}4|k))gu)s36-se7bzPWTw=1;U`YNRUp**l1rI174qQ
zcwL2%z^&Xpk>M{%(q+eFS9j`yl%oQIROd%dgm~w=<zsoJNsDb4jMp+rq}rRCV<P81
z7wVBh8Nc0gRtuuQ5VZ-Dz`88akc2acHfToA5zY{vSQ7R`=5`A5*|&RuC-iU!X-oBn
zU^ldmP8l&@Mrpz7wu!`7ii2MR*YAr#!nj|*A;*Hxf}b4`iV+$z$+{Bn9^xP@fAO&d
zL&7!^>nnt*h+-MNlM&}pk=TbpwL4+0Be3`$SwfiogL77oI)V>%r99}D0~)S6fh+MW
zW!17w1612jsFgf|y%B-}YJW*QG=3`7dHxi&{=)8G5n3cFx@d(I1vq-Sc^|oR@!l%O
z*UfQ*D*g!Hun45UACgPvzhu{V5_cE|g`?bbiqD&8_yeG1YBzgfOt5)AIJC4vEg?n<
zmRqR>X3R-`mFi`e3A9!UV!q{#0Q4;hq&(b^VrITrL>vUx1jF1dA|;@Q2M#MI5Dc+P
zO0uDaxwONhGDNzgUo^C#r$DW-CC6v5(`KSc(DQ2G;r;v<k%+jM$yU6htmtht{BqI%
zvjieu2GaQn25X;SWrF*~4IE-Q84+|$t#u#^00BkzPsjvo(qe;imq)}V=Eh|egSP&*
zY?#`$H~fE(p?0F89UPe@-zyLEkhGEqWL5(vc9XtvcXd$INT0N{{0fJKnA$D9#11u(
zVx-mt!8ySygHrBTWQFesa)SjBD>cb|-hcmx^Z3t!{Bj{z!5T>OBUo%1XX#Km-A{tf
z1E(I~#G7=F_ium|7xsvp=9HLp@aAt6n8GYKGf@L6LdSHd=gU<uNy`&?x~vMxhdy$&
zJW0q@(y^l7<SJ^LyyeFBjQ6Gzbum-fjS=feja)`sTq)!NCV}OKhd%7y$g@!)P-CcJ
z;IB2shltt#h6uVJ%qiv?(pi_a?-w`{Rz-grdsfuf?|eTU4(%;?9E&t*2<9<|#ApTs
zIFi&PT2KQcd7tACMDjMJ%(LHLVG0B!tzI#x2r7@~ye#PfHKN26kt`KW>RlPE6T*#U
z5>NhkA^r?9WCsh%sFE$-_>&2SO1ovklL*2HbMPorp($)T9;@f{{w;z0icHiKDq7Z9
zG1`GKLkQkFU3ruhu)1n6wni+HKk$9V<rZ2zME#&BG|v=*1X9%Rg~I=gIP2Y$bxmV}
zS&-V#vxkXXz8B#`p9iG1!sqbVh>z$aMe&G0H*|_2FR|Hq!J|jpWE&~n9Iw84LL`tH
zxDsU${t5;3TnE_2H)9w(C6ItHIYmc_cM`?1tZSjgjzpFdIVZP3lfn=LlFNi{rs}>W
zH2aDPaYKU&{Vm(3n(=jD)N{TFv=lJJv#<@dq(JHXFAl!sgwsGOz^)>A0?JH+^<3bM
z-Q6cUujwc39BmX<HF#BYkWv8Qa4BaMyS|iJ21z_6P^gilRm38jkoz=wKbu(Z5|R+Q
za1)I+pF-?cr*LTwzG&`npt`O5O7Uz&IkxMC*lY@EM6{#{_64Dy886~PgKCKjzDYqN
zxk&Cc1{P8^d5fy8-Tk@^=ntVg+q<MJ+~)@@6?HyIP96>jSV+X6hKdR|u9i-ypO*`l
zt%JTKY)spWN2{IQ{lyNQP(pv#yLDT{0Daa^*GIn6iOKR}AEh}yy647DN*eFXVxGoc
zNLCA&dp`6r;;LE~mnIrNet~oGeiL_%8?<22_+?V#skQ=kZsUByc3aaQ7hq!l#-X}4
zHv^rr-rOtc-$B&m_nBQy;y2Q%Ab=1?=#?g2cVEesm;ZZ=-o0T$nQIGHAUrOB%g>W-
z;d~8aq$7EOo%`tVGq@Lu&~$Fv_ufd0-@8ORmI5uBq4s3<0ued7nkvf`QSN=#Gd?GK
zazo!h8{+fts;Bv<g3Mm6pUk(DW^4LMe7v|cC}W&_xfpWt$m|rUJ#Do4SyuWqAf9;R
z#Ul*WuUfaYXPF|Jn{RvdEY$9#e@MQO|6<t8nCjR5+QX6KT(wx+TLu&zn2r!JgD7-;
z#>KBU8%+HDyzYJ5dAXYo3_CkZGi#tQ+3p+?ot?>#Un`U}Yz)_T&c+c-uF?g#VqnCp
zt6`^YM>AvUgjB4uZDX!RXl`DD%)at+u%RJ7uTsSSOn@2R_QYHAd&DU+$(5E@<oeL-
zbcT9Au8TH0`e7rlRlqje;9X#6W%J^!?@xuF!oBlbld2D8y2u0mtPYYC1~{a}Yu--9
z8dBpk&+><{xyWE^v(G+)$ltbwyv%~)++u2JFnagGU>lO^@1_0;pFRG$dvEA<FOeS-
z1=>?+p+g&n7di$20#9~33oKXghWeh616HB!Sa_w;9OGbz)j>m9apkf9iTN0dOV~sn
z;jMw4i_T`l|0<IC<>z|7q!D0lu`hM{1Eb6PqT6vnzB_;fiU2fM;DMXo`waneBJ1Uu
ztwp8=t%>0;0P<1@#vjJqC_p7Rmv-cI9_mQ&mP+ffyP5x@$RPIkV_*E&S}lQ!W6$)(
zCX|NXJ)nHOWq!)^L2i5xFpwT6fKbU$dA*tx*H`DhrLx8tP)K=4vFLu;2Daq)3PWB@
zF6uVD1%II~B%<;`spkW8@IcgKNdxWqutrBrsFOzg9(8y$_ceDKHlfbznIPAtYrOj<
z@(j~a?W{N!muugx{C(hIArZ`9HvcU3+00j)d%m_^cUSL=nSBz}?6g|!zAfwDoVQat
zhse=iRH2^YPFN~90@SngnHd9ohZ$rmO{V_z23s_O^DV$r&giqQ%JiYQ{R%}&BVz%G
zfs??MZ-RXzOrr-rfR5jiW(myu`#kRbX>gqVz{j`-ai)c#fkFvsh!aE1zroDJJ=+am
zt!86sxY{nvi-*8O7qc~}1E*TW#P%MuV!m8pyVle~!WZ)f-mG*IPd-y90!C`cVy`*K
z$heS7{yyqsiY=UPjGE%Ryrck=uG(I5Yj0ar6)jjFxo^ld81-85>%1O}`4>k-0a6kQ
zh~)c^eFM(ZPmOFm6e*+B`25)Z(&l+kNk#_;Cd|+@=IhvIcw9gmG$aq&W;-z2<;$%L
zop8cX@%Ru6GV01)p*TIAOr1Q~=Fs;u$q>njmUIXdx~(^&itHzv14Bd6$R;)8+E5le
zgWAjVGdHBA%gnBiFwczFxvw?Lr1V*om%f&R+DP;OXk(%tNtutupbH3+fbD=$B;w^e
zaE}{(_j}P=-=tCH0Z<1jD0H)8^>pq3JX}JXH<E3}<^qQ@f~8#<4lAD3#?7~D2?z}!
zB~1ujyaZGt0)GZT{%jc27b>eKY+@%<FEh4FY<wySfkaiyZHxM@Q91F>kL}#2_7~1}
zllS@6;4|RLqHD~tFit2??=+fnw>#ID*5~g%8a$`vCzyN|E!$bz{tCHV;Hc0vA6}Q|
zuE7u6J{*hwGetr3a>9m5AlmInVVqG*DAVUK`a^H0d;R-d^Y(x`WLAsw_u$n?I)qQ4
zZ)Vp^)D6;#yT8`M?3*n|-tUIw-mSlr)mok(K`$kO>XfDKOpqmu$v;ad@gfaAEcfy-
zP+!$`G_?^8-Vbq}hg&UJ|7zJKqztpwoVay^k~Z=|AP@=MgZwE(pCEL*aN)j-6w1^w
zCfe{v>WD1&`ptg4glD)kIiFwh1FEe3Cg=5XF%|4VFNGfmQ?Y&gJ9X|z88J%TKCkU*
zMTaKNu%Rn(cMuubo@iYl{QyRd61INRtTmftJNpmg+Hko6bVp0wBDBQB6>yA_KOXt*
z-L-u@FE50td!DI=#(fjPJNM4STt_3{6*CXD8U6%owTVKAS+_c&Fyv#*#_#hle3u<f
z>2{qZ3Eey_prL8+;4cZ?)n^hM37#g2^(^AI1mv>XSSGT0PFYzKH1g6NRW!hPMJWi(
zVRV18t*Z!h%<Z>EU#R^&gA|t&6$QVC!o2<VWqtF5eMKR-DbL3%$32Iugw=J1>UDv%
zKUU)x)uoDHyjrrp@j+V&l7s{io<isIqDVYHvP(TLUdvZ~(Tc7hQ3+9%XL@NgTs`0@
zIlo0N))4!g;J5q#G7Seu*)M=0CMB0=Tr>hjU2Op9qMNI)scDFu9idu7k)Qtn_l$k?
ze(JM>lWAYB4z}jc1X>;cPN~_s@;CE*wXUe-xLXzQuJhT=BRT)p<<uEzV`XdV>7{0G
zu_*Jiv=T-psLOJNS)+=>ugv#tuG?s#cDOfZUcu<v?5bn5%FjT(*vI&(J_*6lPXzfG
z9=2m-RO4G@{zZ&YI1wV<mVX?B>M=T&Xwj?h-}|KNO}b~<`{y#|-HLjno~}3HTo&)1
z$6{IAv!FFnw!t=w-|L%%@MD50cP=35O;46@K{->SOsCURP4@(Rh(C8$NxIqhevQ^l
zw_<?^;5?jhXzmE8^^XMK>j|}nL^p1#f45?-LE?c{0#)D8XKn}a9*w5L=5Of#*}K4U
z9PfX=4-*WYl2?+Ht$=td#kz{mugj1cIT*euYOJ+0VCA-yK#y2I9ex-XGOEl&jB7UM
z7KNNr11#9iG1=`)y#Zn~wyVD0=K2p`gzEY%T<E?pa^O#6;KQZpH23s;JPs3^2+*gq
zWzNn5hS&(bVWHH!ylVY=K_N@4$Lw@S;J{*N-2Wmj`QPy5z&yii_}-G7`|pa|f@a@l
zwj1?qy)k=b{Gds()0%#!e$KlmAe4ws*6_bgD9z5@?VXW|{Q2PghS^`+ybaLl(usf)
z*bccE|M^<S;QeHW&2}ipeRi~NcvU|Q;pN}+#AXn9=<(QF?RWfs$fFhMTDj7O<Dae}
zf+z?xv(`6l8Q-U6d&9vFs?zLz?RM3Eoa1;9)7>Lj7Xg9RAIF{O={~CCe7zwHBiG|z
zT4Z6yhP}zx@Stp<9jSx;PRv5`%OFPJP)(x#Xg|)0Z@T?T#o(No=5lo#l^C)fQMDNx
z9>t^{LrJM}z?Amb1cfm&DpBuQLkpF{JDd#b;nXo~&{!!V<pzU-#7ZalZ`KFNePxWs
z4%A@c{QR}18(Q*yAd8nvjGyZ))4Qjl03e{d&vK@y62WU*Wbi1a1n(4Ox}f*@gj^xQ
z)y%Ag<0dfj4LtYPO05gcdO=>Wl_;VhI4!4Lkf);HR8B0mOAk45XSv{efIu+`c52rP
z<oM;cddOzZg)7%QgRs3J1mn{9$~M27WubaWbvQ^wQ>c>@Ec2rK)%`eQ$AM`TbVQuK
zDZz!5RLKehOu~hYr=Z*&G}>m?Zrk@W*_GOjwYJDXOd}iix3IQNK*59S%hBXah>pz%
zm7HO@`N0!M?v&Y;ZaxF-*?xZ<e-sB4#EKeWoFZhTGfPMw*l0tgcy8d^710Ty38-&Z
zft5QE3*{KkiI_whx*(2?%U$wS|3#>E5*w=i7>WWQRGn>1n}Vom<QIr>$!o_bCy2Kx
z9;j-=<ewTd=f2Cky7Pg<^(J)>fe?i^y=B2q8?dXN?|u~LD8pk6I(e;SC?^bI^Oyd}
zZWUUH)r#GiL;!}cTX~HDlrol+nD`e8u+=j#gelVE5{tYIp}Jw&Q$xH9X($C)KCrtX
zDJdxGFY|<1Z|Ij*S1=cQEXG0CUDKpZyo>1iYDb52R4zg%@eEBQO$$Qj|Bb^46>@FA
zdzAf?fT8Xmw^9UaAbG$7E#lxVT7?~y?DkBWf)Cx0R@0VWH2nDv^4B2{Pb2{&71=85
zXC3vNew1{0cm&n8U-w=C4vM%}jpPBGLVOyquR8kcFj$m(Ngm1GSTaw|#jBe)gOV-+
zomgV(@A43ZMy`~MjFCHm4asSMN?#MFT%kG+d!FvMP{%|iLlk*r;dl1Hx%$WNxXyjj
zj?b<g&NG2Szk;Aq(R&rNHMKl>fzomJJW0R(g2E7eqC|5+F^4$refy#Ro>yH=tt)h@
zU^??jTsP)!%&c!JNub3q2MiubDi)<S8q4$-YfR7%sWV9^dSvD%T-S*`2c3no7nDpT
zVzo2rCNj*=;zSZluaFIJd(!J<rx71Mw{)_5tkRyKEgpxyBRZ>divUzI#<@6>sV#GX
zB1W=@kCo>ae(R}Bs)i<DDSKy-oeJ&W|7d9OTWHvdw6SRFZ0NRa^65j#nzqlg@A5dl
zkdnR8{4gXv$5Ih*;su4^f%_o!87kHGrU?RfXb_cSzhKl-?}Hh>P%|Ry-`kC$*OQ;c
z(3d(~rab#53F9h$rXd^ZCqXJRFZZ2SRM_Du`pI854U|PR&eQLG80vZxb$Y!C#uPXE
z=@Ep%iHi5sO|c=oFg5qYtvM|B#7@;&3bnW*V~I#c2akYp7T#zA6(*e?{-vQ2MFW+R
zYG8{x2HqIV&d%jGdXdVFhSVGhqPAD$Idfo0Y9Maazw_r9eqbO_t{23@c$?+M9h3+U
ztevAvb&A$C2v>}`wwzNp#CkZyzS>Rm&jqs%9?Odgo7I106u3|!VefOd?{tip>a(<j
zGoyr)(`v{XAO2C$1FCDz+R|phs3Ow<vvfsftigo>$N>biUHS>kofT~V9Cf=xKnAl9
z6@o!gY6@yn@<YMpy(3FkCPo637aFz>C8DyhuHxPx6(?A*)1Y#UA#58A1{~$DDw*)8
z&yNlHto-t_f4V#I=iw*qaVmPbFpvDeY!++}XiCGsz<r4mA5SIuhFnP9OIgL}oeiRa
z*j+2-pDJgk&mt6xU)s#sW~w-!@^$LnLU@h$v#&NI2xgxPeNr(}b3|RrOKXXRi#KXl
zO<hVjv?wV@cQ-OcjHJsZs~}>NF8zo!Fzcyc`5Idw&k`IW0?wUO3#U8F5ddu2T8pUF
zW6%7TcM>Fkd^}-Xmzh4WGM*FVj8OM0+Hg)%9JNXOk?KC=7P%pWddyD#8DRml%Wb)^
zlK63LRd#p1XIkocT%Kl(sjEL1JV2j_)<42;h(VL3>2O?wC5t)^mrZ1UhAn%MX(6_t
zvMf+Mrz%;D&wc6j^lw?0!+P7M<UThG!5c0@PytgUYh%I)lR?z}c-e6OeP#k?B+k@G
zrjN{q%z3+N{FO}BM3UixWwIyQk@7w)etk*K57rn~y)ro>8Pe%-Y0B&*#SuA?7f|<)
z7|jCSD#ZhN{4*o&itPu&Cg^lpKCu0tcP!~=jQ5f6w`K=e<GBZ#PI0Q6UkV*K?7F8`
zkLC)mO{WooS615DIZL7{<+cQl%Jm7>qLvuFMSgGK7F00e%acnucFi^Z>6x3`_X<<Z
zH?7)D^67o^GAhSy&vUiRR<n6>Wb_KUiL^qcm3#bze<kZfkNn~MD&HZe>4X$-u$A_}
zI4|x=hto^6*^{<*jIpZQ{P%K)P->w(k<X*Cz0=cf@p1?oePUY~1uh{g(iiF=?h#{^
zeRU|QqB6px$m3c@=)Sl@_&kjN2FpkMad7ERyg<=fuRV*KPY9}oJKR@b9{PJ;q214c
zZc;q|WvW?75c~GV+fT_uW*#l&*>ticb>Tb^?N@nIRQ|scV2%&PT<c&k4Y^;~+VI~x
z8;x2OkN;(7v?W6oS<!B#(+K<J0|#DU<S`I#hk#6G2se<V`er1NP8le1D;^%%ZXxO=
zDJ0f#r__#G1^p>xJkt{yI8|dEDda7P<b8IK4D$c-R75?2u#_TAvbd6>DYg?lyQ9hQ
zDRtDjGHz0GGW)1T3bKrgB-+P`>rEgP5LIF|i_pJ+ySsvAn7KD~qRWXH5}ri>k`T#3
zd1aFRt>S?z01JDhjbWq{QV(}nIB~zZ!$L}p(;JqO+b;mbs`Uz;*@s;Oq|Hcd7=@*?
zn27_txtPg!xrR|&*<gCOZzf0_%5vu=A(r@ic^umWMzD8NC&0dSF5JSe#TgHR#648L
zgKJC}&M-6+9J#YJED<>sW%l=4O=5~mkkkg0KOK~mJ`jLYKt^_xO}DF-^+T232FQyi
z{4sMDP0-57A8~!#(vJ8QCLF0OvzsS8F(!0G5?0n=HV0%SAjGhYN6alDj}D%NEYA=o
z(TZa0(YI<aQl<}>Vqw>(O-)LL(^>HzsoF~N;O(xqae`wO{LudjX198mH|cxl&3ghl
z;>rypf2EZTPYhHQPik`gfLUu9uy2{L$^?o5Q4%4;ZM7MuCAXpbSW_%9CMxS=h|$Gn
zeugpsp5%jDQay>S8ygtXATQWij`No|HI@JOHI3&+0w-(-MdP(Q{6X2C?lcEMC;8IP
zkTyfCHiu7d7VPLX&kcT40CqBY5$6;EBilsJIaPAsEJRDM&_7CJD;`vvpTNK%pO#V?
zBSTE(=F$}LppHxp46_|4ge6T(RM8^7JyCt?T}<8G&sDLuv->H-U#>~6%Qy?N3-F?e
zQP`XY(`(-(2yQK;)|bI(StNK5d|8<m$6d<K4L}9YBqt#*rCL>M+ZM3ERctbZF4eW*
zNkhj<Ie^4s#0Bw(QD?{3Z(xVnSH<O&9NLhkr-&u)6A8&QaZ9SAUZ*k&6mwJHM90Js
z(;I((=chi?J{esu*F+(wYPZ2D@6vkVM>rRWXv$IgwYhq?r2NYKm5g>zb6I?jr5rVP
za1toi+>ZUOzTAU=e7tf#DEM%&51MI+>IK6FlZEs2Y^KcJX>63tBOEIwR3@VjHB-?}
z5)q9FJFwV`E<YPD8%8->eTOUt`ykRlE$NL=I;}cL9dC$nKxxRa?*&kAz_`hOx=#Qz
zLJG<PUCb7^_g_oNOa*g)f5gm#$xspZq<DWS)@JtKO0Ce{Xy(fDoT6cN+rZZ9b|c%k
zTNh&G_7!-&_l?gOlmA`yJ4{nQ2Q1g`ou{A3>7K;#)`|+~=7!0L*4Weid1LT=Q0Tc+
z>af?fzgt(%X!?G;O!t`%aVMy^V^b<ueb>vsv)ts@5{x7OGWB{>Hd81`$<D#iyAdZC
zj+NsdO7k&~_5_rWXtU~Rs$Adwv~Lejp*iU|ZL-PJyvnK2)zbsx(sgc^E@!*g2Mo6)
zbCX%hMN4Z>{HSURp&F%F0~x_kL)!Z>LtH3Jy?!IY@H@GVI@^lbHhPydWVFI5Dp|bI
zJxAcoN=E=$(War<Z1%*RE71TAh4CI3g#Xh2G`>^Gb0y-cj-czcsJOe4n*{@R<R1zE
z(rrBc!2yE#+1U{k73~TBNY?lHtFHAt`Gj5G)Tik8NcKGIS-KnY3DH2htu4e0(e=8g
z<8fn9-RCJJ0O#k^i&L``?a-sRjkL`W$mi!-U1qfXLDkcsTAIi3*T=L}0pu&kh#&>;
zeQgO&a`tWYI0v>|qau`w=z|X5cf!bVO`EEh&%qa@-R;u+b^C35_<A(_POGb{Ypdb(
z>@?LdJ^|4E(fwvL{HTK6IV^=%%2w-5EY;o~p0V;UIEZsACwTneZp=ny%C{gfqW?r#
zIKYo-2h6W%XAhRrW}ntqS^tBC(P+dGX^_=j2fae<yJY}gDK@h!qfAHD=<dx!qh}T>
z$HZV>?}5r)w0=?pY_nw+Rs>%0hIBP5>+1ui1wRy5I;`lF{#LGD)fyy&K_M7o3OHVw
zIIhdP_r}^4_lexe(7|J1q$p`CLm2qCBG1ju<<-=HJZ{*q>y)KEtm!DJs=`%wu;ZoH
zCK(awI$h5%&&)vUG~2QX?LQI1>C|+1Yo;^hS}Ac&i+MZ0G*)6U3J4&uvauPRCSuI2
ztU$wce*}7V8hjehza5$#(ktaP6*UzmXJ&$dL8bIK`}+bo9kyT}9uR6qb~tccDJhXA
zdO;Gy5V{rRg3tyJ1iD@<lL<$Xo{u{S^{(Y$BlJ*r3)$q7EeRabqh5wHu~~9lQ`MB0
zGORoz1NWX;i>18wkg?GIoTobs4h*NyIJ$7ck(<)2(5&5WqL>Er!d?fA4Mn|e+9L3w
z%F_M_2ql!_ZoKNe;%>sIb?P?{`_^q=m^7dvcyJB2TOd1aQI2h+Ssk8T+^%IPET-L3
zDNMr`ZlG>Kll6)X<~KXQ<}m_%zTQ*>A8~uwt4DFI7ioA4^RxRCS_l#lG*m`KG~UEz
znUZho&O<+>&XAxWWP{89I6<@%DCsxeGyuJ|49y<PeTMu#%=*;ti?j)o6vro0b7GTB
zhztf=E53fI{QFGlz#PQTv_Q~y^|CSlXOhmeef%+!93Kvyctv}@gyn&_!zL_74)NC?
zW_pt-)WkZ%8SLV`GJY!8SU)nOolPl)W)lU=pdiq0_JiV33{_5H6(r^dt%j1b$LIMw
zd5st)?Hpp6i#XT6C7`s^bTnY)WTyqtK{epsU??yrTcZB1E)R$Eb3;7uoaS!1K0apk
zh;>2?#<(6=+-4aj8U@XmK4L^ZI9iOGCO->HZ^}^W`grA&QdA5li{-^WVZM0xG)Uj_
zbAJ2`&|u5?eDnWuD{&Y*(wcpRg$WDu)gvVdy)r5#W*)I1e(;Jvf*>H=hI5OhXK%&P
z7nmr6<5cTm@}<>S5^}rDhQT<VAc!|u3WPF?MFs@@>QKpR<6Cg_M9fPC1z5;ssRo=_
zCmGX?s6~zr3ogydggnUr&!IGC08zw!<&PVn{iQ>L(MutGr(#qrIzeb!rW&!PBgG*Q
zsJ?F){SRFFvE7_ly>Eo&Am*V(6RL3^2vzO3SmyypI2K>=wj#+>>5zGnaoOs3nuW#1
z+TwFo-CInW#4gb|Ze+h_dm0@<EPj`m0jl{kpJ&360kEG9pbt}-SM~myZ!^Ae{WnyE
z2;MQ<!8G1BQ{FYktF&%4k3{~y2?SLH>>eO$>KbhCc-WRo?SKE|GS&Zen#q3)cQB<&
zmf~vNE=ALzsT*aPobL5wlh9BYUlIPbmN10<BHkS_jw*^dT5})`MA|*t7)hg7NZ+6w
z)QB(RRnYIm6<*g9<`r|nP*bi4hD})*!j{Zm@O4p$%&FsU+$%_lfJO%O`8*F+SA}zw
zFZZ%3zHgSXDSe#*J&*P3??0K|%lc_Sc7INaIv!3th^0^0I%8#W+8eb<y;=?i<~({l
zT_D-Dk=?9Dv>TDEv7y$sST3CG{)j>BQTf*7LIDRobjcBxa>&F>BpMksuCj4kpr$#F
zWH1+~E7MRntC!evp}y?l1GFILwS#4Kqobu-NrpnixW5Sw8G5EzrHI%v49}o|k=N!C
z*K-dC(N9Jn=_~GtiNV<5XT-$=qMDm;vdXCi$W@qRKXkL>%lz`xMx*+jjo_<g=fv4B
zt17mfUJ#_*_KTSpULZa%*txsyPQtRU5`Jxt8fS$Fa_81r!W@z<^=A$gF@2#VB;u<T
zy<(i>T(#Vq-^loQ=$5ZntsT6vR<pUlexboHG09`ns&qe^^|NQcSyVTrX+<Iy#a@G!
z`($W&6;km!)tOTpM<kC%2I=cQ2EC3f2t+CcK1@s3Ai}%i;D$S)&!|ewSvM$%K$ou2
zoWJ?%Wrwnwwf(6s)b3*og@J@%#djzJPpcbDL3kT5)Tbp6uP&f>>%(HzD2wyBQ-*cv
zIEs*pVm0b8vjsWEBEXg~?{+ybf@TVl0MQ(fahb_QXmH#Ed^^ku_~3TamDxl~9Fk*-
zL@`r6rkuo-nKd9jfi&h}l7&Ma`j(nYSI<^F-tbK6(V^@2JrV!+dQ+g#9RX_dhF|At
zP&fYr(&NfunMD?~OP)&6I?GAk6C{1wCr4In+()+O)F`}oT*Mq%5uIj*(IJ`wFJxF8
z_SkJh;|(!m;C$qY)GM_XPW>_U^Yuro2t~WZ*C)|^9`piF0<Fxu@j~eHFY5EIzW;+f
zJTzrL5m9?41grtWGv-poHz+cv#=T*ztWm)QaC9;L&yDf(NIY7hm~y@4O-G!Kw;6)-
z4>Y1Ku4Nz7<m+r29tXKLz3iH%-$>aB5ha`JV^srZyM(3Aptj<aLy(4cm<e2@!cyuO
z0ulE#i6JHQ<=*g$m1&965oJ+uSj3N@v`O(6+@Zb3nBd{!wgu3pbXx3>Svp|^SBy8c
zj2Tp1*P1QU`#JOxN^<A+leMB77Ho3IZ25iaG6;y|>ud2rFi_uUL_k(we(Zt`uQtL}
zxcJ_#Lhas0n@hzHn4ZR@2zWo3qCpB&?#kUi_8paAuC&g_IM1DZe<!pocf<NQC!=;6
zn>|FPiZ2sx@4W|*TMO9g@`ZXtaCa}RMD&Uafu%BaU$9~4vejAKh3VL?whVp~*nNmx
zYn8qpFdz(|W9;h9s;-c8w2^N#ml*sLt;P}p?Yu2Y{$6WA7*Ou#7hEPOZ&pBNVG59z
z2>i{^k3hqS4AzoItC4K@JSShJVSbX#q$v1?JmoZR7OzP7F#Emh=95}2r1H5iyn9x~
zD!F%W9txcrFXFTm0iq6qiCZvH&=X@oT9KW86?q`mzk(4{<bcrgOuyx*PKTSQ4B%ra
zGQyHKfcF{|QpOSnFAvU6;!%7N<*w*4YwhvX>pup?zne<kWxsO4-shSs`QB#;K&k8}
z5RK%($#@@dU|Q|j?IjMMHLl!gM!p9h`98dn23toY#AX@G(I$p)neUFbkS8an{3;mX
z1)o9EFG<-+CP%|B3L{|rwVH)ljvRKoai9;JvzMKXb@k!sqwJ$)-ai?yn-d93GNFT3
zGcv&l1cl~_sIf814`SL<AQF$f-!Bz~KvhnwmR|1xo88j=e*g_Z^1f|gQioR|4Qn0V
zRxbm)RJ+qy9z~;AbvKxz<R_oTz~a>u34{x$Sd*RkLMjPGS&JeDbA&8|)h18i3<Zv&
z(QXK3c)JyxmVetYE+M2?3A9xv_zS7%*E`BHCUBb&v*0(W3nF2YC<niqPidGopa-0*
z1g1E{UQu?bHR>Y4rL5qJcn$rqWkijdpwoDOwl;K9dw^~>)kjU;xuCSQ(OuIMf8lkv
zO-{B#n4U?P;3$l=rVZNKuq6W}`ne4kWx<^Dkk2L0GJ#1|;~hk1aA1WAHj|v>reqtH
zS)i?rph-L>;YH6{HDOJQ6?2}=@YBVdsdNT2pP}6?;#D;}92=GXDCt1L?iyXv9<X_U
z-)Pq0C(1S=UFg^z@Ed47Eq5#w$0P%VN92o0;Avra2%lcf=Lx1t%EqSJA;4C&6}WgC
zh!yBdeC#GDp^V2)=Mi=|i9E_dRwIxV&nm>6lohe8b|0`5n$-P>PxMMh2u4ddLVPKe
zNDkD2gyl}1(;i?Rpj$(Hv`e~(2h`(igv!Ol#AL?K8NsCXKuZ&dlnrbNTa6Hm;%abH
z(FEBFoWKSW1(U&Tf(s>hY@|w{jl!!CX*GiQcnF$+9zZJq?8Q^gTH1A4Sj@3URE^qL
z2nJw5hSWF?w80eN!uS*L-#;U$)oAU34(WlIZlVrZ6Kzzu9-u)ww%%cKni((4A`*Bp
zCIBw#N;XMJ0!vwmAd0L)0D(-6wgQ*y0x4t&3zR6A0HRg`g&4=xn#B39d<PnfEP$Z1
z3T8#zG#nx<^upWWg4zsX1i&EUCo<eh`RWBHa;&eJ3cTuK5{QgLrvQtqUXc)<(ARF^
z0lFVlpKeikUCH=7;2x_Z$}?HajEW_~D6L{iI859n4n-1J$~uVLMVhc&la`~}wxX@T
z<tg<k=!A9`%2R-gQi!l!`5{XiNKx=@Xa&6l@-u^0BWUC@RsbX}3|v$?iI%2!KcOTg
z65giCDv)@IR|gW7Yjmy)d4O&Y)u#(pQCB5e52(i52r^n(FOnFgYy?&}+LPB4;g-?n
z5OEhd6iZ+!>mV}jK_W1cF&&Dcb(5NS4q`<Q!7i{1U>9$dBqc5&0VG2mcpgN!tanh+
zoF1tyy>+;RNfz1OU}+=t(5DJGY<xz+p!2oLiDYH^;t2ZIfrQGr8rEq%AiA^j+G#4F
z4Q*Qwc#ON=Mkp4Aqm*GIw-scqo(P#JV%~WlP&u3=Bs-)@3Z$$>B!J?|F!FC%gVcr>
zQ<Q{r;0fabxd5D>z%G;$sFcdMX<NZ1gNwI)D|(9!A4`GjM(rvC9Nk8cm^>Z|SqlUW
zHauj=t0O5z`Nem5(Fr)cK2-h?e8w$TG4yi$&y0i<W%>tMBCm0s&o9(=qOGZcMV_vd
z+Out^8U2iImeEE(qrB*6)6sS+Qy&z0jXU1-g`Z!@U!twig=U^$<kK$YPyAmkC!LCZ
zxf%NlR*tTobvN+j1o|(u^!o7WH(!Y!NrF+Mv7g<<^9*+~;*7EicRk{00H=1i{zlBB
za>2*T*mv=@@YmmX1+$Cejx)<aaKg?L@m1f~p&Tmv@sTciHMaN{;v!F1@{QXTZa3A>
ztiy8d7qfnZqq?Gim54hL{c_z6=qD_XL>$YbVT7AH?Rb=9+_y|7ZxgEfNytYyUI+3u
z&kLVX8BH|Wf#;W_OlnKfwye(^?M!@Z48bxn&hTvaDXe|@Sch%2d^PJY^xv$hPTZfD
zvHXf<tI>DIqMer^5BIg;TfS^1+A_r$GkLrFj-Q5IV$34@NFR-LB%k^Y*)kRXFOevZ
z8a)hsjr|36Gd|V_xi9En3|wc}MYc>Ooa9exTWXV)D3kuz(Y5&R21p-WsZ1YAZ_a*~
zUHKP}T-d+qLR!*GDXAm9BAc6}zdMQt+WHmQk?JivZ6rF4kIw^L<`vnI+@R=C^d5;T
zE>{0L0BhKk1S@1nSX<UcYAeWOo(P%9m5-Lo@k5r$d+eF};i^k+bjkJxD5MAw8pM7T
z<EyciztROA6Rx1J;kgAikgcG=6G%bBDcz_ivE9A?4McKs3Y&11?QaNVHNb6+mKJ=4
zw5MX9R#Kn{#C=Hmh2{2ZYil!Zr&y1ha-I~%XHlYENGIDxbxFc{`PGSZKJp~KBKvab
z71>M|ZTR5|4F(dzFuk>5d0Xc?fCog^R9!oOdD?_->;aD{F|bE`<~2!1Fe-^5rmTE_
z#Uy|+krYQV1k)r#|2v5$BLie7v;p~aMj$iU@EjThABjfDSBO^|$_UxCD_A|R{^uiX
zmU+ssBTz3LnDk?n&SY>hgU2oiOOAde1pzKnAAo5J%a|p7M#9Hu8r23Kpspx?+CZgN
zp*_Go;22xm!Y!ssGo#Y#i&Qb#Ve$<XDUY0j#4aRgiMX8!C$nUl0PQ$?$>1@8l%WaR
zkvP}{I*QzQ6U#G784emzbkPz*0Pz~>tbvfjuhed;wi5#F)MiP6CJ+lEOk+%HTgJJT
z!+C5Zt^)V6La9vYLR$b8zh04$ou~5&^#Hp$P=kC;s6s7VdmxerRO7xck7KfknqLwg
z53eM~8sZUXD@a6MS#dKO_-NTVn=FK{MDS&Aw@{hVG|2{31QSH)FwDW?k5}-Uy4|8V
z3KcLN>=8<t+9Qu`sa}zA81BLD2BRM+5c6YKtVTG4H@934VRiFDy5LSDoMrvghRbCd
z5RL~#N0qPPNY+xc2SWBhloL89mzbn%c$Nhh8l2L{I%#f@?^%)e;gnED5J9UEwuDk7
z`Gj&5IkgF-V1fq};+qi=-lTD`P|<;NffW2)3jcPq3oB$Que_=i+!DRGWjHf4z&jwE
zs}U4LaDU0t>}w?4BK&r&7TGu$j#*&?n+{g!akjXFQ5Urbf_p%8J>FS^^Jz-$fp+(R
zY943{qr%o3wmicJ;@<Xi3H^d*A0*;qfNTsx96}sLF4_j9f{-O4IGEELcoQU%2?7_$
z1rU@%mtktq)d<|quqJgOoUQ?qgNzrsA60>oO`^0SK^A*&Ysl?@5||Q)VpFge+#v7>
zKy)BsI#6e#^#FA_`4cU_rq>?mP#$oMw^7*^1+R<L1rVA&5rRN{jggHBi!_g@HL@SL
zbhy&CrGd0|amHw22RdjB1qP{5XR#PL3m{1Baw6f0OF?6TjiAUB?vr8ewoU3j!~sx2
z&PMQc2Hw!D8j4i{b^Wl7YzX3(J{~?HvpLGi&nu)K|Kxtq-vK<})5ijEYZC2&PT+xn
zom>p6t{O$fFLC?w`66x8f+SIl{5DY3g$O~3K(inMw=`r+*{^hbTu{*1bt6=PP=H)?
z7LAd!08E9W=)-SV<YGYA;c5hbo21=pRf(-f;A5ZaGZHEe113Am1kv_TDlaMUrZfy(
zT3VY}kxlJM^vI`!!6?$>q4bz2FCw)`>!2rT4$vb{-h+>S-fHM!7v+~;kx;rt1F1jJ
z%UkFwKH4kY!vpj}pYEFIB}l=OVg^!xRPq9nsaS)<qEvF?wBy{e#mz5YB`OBSFM3LY
z&0~VjNh6hcmYC>cM>vWmsZ3|l7&*FFK=*hh;Ygr^oB?coo_^iawuXz4o8$V%N!{Ao
zaADN|hfPGp)QRmB1>P=5YFy?=2ZN(%<7GHM0vmOpLbnJc3R6?yjlGA!Bcu8Sa!Pk3
zqHZOB$OrTmzc5oqaRwan<z(1z*1=(l)v`kNK-ldbvUv#=$LcPP(O$}kgp*l0FIq3S
zP&29|6V5rj7mVoN!zAsKp9UY?I}Tp>#b{HLiF9Oy90!=+&@P}iKp9A=$mKZ*^DKy9
zbkYc7(wG@GzPQDa06Ub54iG1hfEJAdD2b9VT%ZkL2hm#}g;M&3Z%dA%4HrwnQyv8{
zZsf>O!{C_X4mUq3DJf>)GHTRtIQF=s7;ZAs5Y9I-`EDJI#{*0_9~46xYbd^|qejxC
z?M(0Otdy$<>Hq*h07*naRD=gM>~w-dD__*F5JqIB!#!(vKt;3lrZ295-)gD!f|LZN
z<9p`9bpw0Cj`~LU>5@&5my!%Gj2i@ru6rz1N~|Y5EHZAAq||N^zj`=9gFA%>Xvhd~
zlUQU{jzt&&c*zgMb<D&<I12-be|@k6R&K5(u&F!69J3_(oWlP*pniWLK3G#eF2$>U
z5ertLBh!r}*d!2Q5Xuk;l@Ll=2at;VAFGi9Waa=Wu;d_j;fYAl2nIHpJ12BOB-wZ1
z!TZ8F=bj38|K>rsX2zwkZtX^R`tiRpF>*aP!1xw&Y(Q><QZLdSarD73ai4J}$7gfD
zfTqTJRz7m_VK8yu@g{EG+yzimYxE%#D(Xlfl8*rreW0u)Dj|V{Fyf2yYLSJ-HN4^`
zAmq%%+)Nmrl>r&_=#e9kC~s<kix+Q%h7b?LsLW3?dQb0+G#J?<9kw;_JuDS%d%&c2
z52Sw1%(ny41tn_OQ4imo^Eouv((77v>Zl$FyWKl#JymwaQg@nLT=$j|sM2VgJ9z<x
zl~y#tMGvlk+D7?a@fPaBxBzP1GW3mE@5sdfdH%R3-_vlClSjx1Oj4Eulpszh94U>}
z3U-?SlSL@9079L>@UlYSoY(nS$0u4Lz+|^F67N3yjfZ6XvDnnq1U-8e!DpX*VW+c7
z0dlk&q5gsO&%gZ#UVdQ~+<xZ_=+Pt7=GK4y?Irl{i?iXE0>^49+i$c1gQFQ3Aj#MO
zh6SQeSRhe>H^3chcG&Ffot6p@jp_^ESJlBi>q_B*z6Ef6&m6c9^D8jWcxI0h*i_fZ
zf`K8KX)qgCG5)-HH<OWpk@;o)3*pGZ9LU7R+ls&X?^wMZM&T;Ng$OS~*_3Geq6s_j
zV;gtDyz&~jV`y(&smNfs<uwiPn>E{6p1wvS{Ki4OpagZ5H8wF_@9(aL9;nOD7E^#v
zW@@ioc-F98kj=o=ibD&snf-Mb?0j5S4S&K_nxFM6fP?b0p#XoWmtoLT(cBD!Fc_f~
zoX@cidte=>59|d4FgU4hYKB*KRKUNtl?$=H*JwM9ENpfZfyBuF+XD&@=?N*>snA^A
z1Wi@VKwBBB?pX@kXKjTEf8P&!49#ZZYgSjmq6@!b`P7_L*zb))pnhu|BxfW;M&C>*
zeR~@$|Mg<o6rFEF4@A@MWY&E@9}4@7%z?C&Bxr1Ig)f&^!Y`g(3zweQ7fwC6Cp`Ve
zR(SQ(oiMClCOmfaa9FXq4z7J{6`Vi04_tJ7F&-KNShB7fMwIk`SLT+&GjDEd!`j+a
zMN{`%&lv~@j>&~=?6=kREl^$8474Tj;47QqtuJ@Oej{?=wjU3KqTEzyXl#MmU+jj5
zXKrQ+uRggSoQA$3f33m3FQ>=RM}zzDF>BqndbkpOCDOeY4Tgy**Yx#@D){B!)<ITA
z3cPgNDA-=s1Q}^b(5C>mM!qeFyI<NUSR-De2_$}6awLvfqaZ&u8_Jt&pt7k324wVt
zhc~_nUsSAwYX_bH2jz{#u`V6znj2tl*-{*n--P{hN5JI+kB3e5JK<L={|!IscN831
zG#1|7xd@)$`mtrBSP?J+3Nem}X^{~+fK;?rC$ND3=R?FYL~kRv6#yuZAdpxU;IfFz
zohI%#4*#LpanPr@7en53+qLX^_)!PLoCv{KMrH<Fe98H+=U$^BH8mBgtE%CVhn|M@
z>o&nv*IkVN&}}$_Q*g3$@d|kAvFD(^u7Q18%pb_)1^OgGJ<fym_2ppVM7@|r0OKc&
zg;P$S0=@fiTQ_dl41c)$Q3D&t#i2(X0>vR;ux8_+LX))k48Vyo6_wM3-#0ytk@ZYV
zVdX5GxKps>5N=#<58!2h)BEH@p|K2pDFzEudgTG$Bk)y4Ez%@I|BO^N@vg)Gp}}zS
zI&?afD{(@mw7#whHehf<vil*uNLd(++&jFO1rfwkfcP5+_h!LGBwK_GuPe!$T$l~%
z=CUNG+#Bomb!9F52ZMl03<!?Ht&qbouprwgnAud{#IE^xrXv%1e}wg??UDON^kqQ=
z1r<2%zy-LCGZ_OaRigHlKPsA_Fxvs72u$fX@TC=HKtpLgyQbpcnVgmk196g}RI|2*
z1q&%zsTg2bd%@W7K(MS~Igp&m{}D{@6Z^4%B7#bdPLKzpX?HSV?2s&2wxI?m&s|X0
z&;keTkq6Tb><NojSF;K3*nJ9_rIYv0XXTZfY9Rv$gG)~63$%1!j)CWRY=4>zi*otc
zkf5qX6l<$HjnzJ>S6&(vVjx^v*~qRrJyLKINQR#r+lQ6!yJRQ}A{MW&0UC`?$3Xkc
zLwi91^3av)-q_R%dkoC7Y1y#70k)MjGJo{OfIv=r4n|*Ztbw<`+Rc59fy}f?MJNjx
z{SXY^Gw{Bn3GtYH3Rqwx^ZVrkpOHWzMX5Q^KeGt7H0;K4xDW%1EF81a;H*9eG8N;q
z2f@P1weafp`B2$h2gmdr4~G<tfiEgoKxsn-jLR7eXZAS=PA{H>V|hBvER}xE%SMWT
z!hq4(=1LM!jD4I2OLhPQOXMb=osl3ct_ldef|c=80Fa%Ng-=%`Lv3vx<mTq!KkI6N
zM*J}vDNztHe($l2cf<NkkeZeTeft$Ny+el&#(-iYeE!*2&`{q1dyU@%4nAyuPm$IN
zhOpR8dj3z(WI@CipMM35zWo6T3iI7W9_$`qH$OrW7D%L^laDUSF+aU9Xb6&;u|Y0d
zwi!Oel>tg)vvDa0({U(^(iO|Lz^_(sgYy?}fbXm8;Y*yD@4!`t4H%hGx_|vnR{p-4
zNBPfg*^Mh6_LUK$J2<Zgq~qO3lk*izH^bALb`cm(#K~PGFIxoO>-uJCCEnP{c;oP2
z;DYY9Ra;>x200WYY&VuHN8l=hNPpVM&ydVP{x!8YIN_jlXh9Z}^&QspmF*Sq()Kb&
zKDj8{yhlWbkEY>;PQPm`hwhf&&Q}t)y|xMJ@Rt?^6qHu{-(pyN?Lu#L__K7ulux1T
z3*HU|2le!()tH2OAli1n_VHEl!@3$af$hRcmC{}qT+Clqg}aQcFlHbR91q%)4`Oq$
zjSs*HkkZ06)o{jdmSE6P#mepd<*IvxV1n%Z?eiO$*;KFXWet#v0malwg?M%VU@fjF
zJooN)`0rePZ=bM#AzQ^DhWSe?VH(~S>vq^zB!2(m2DtSvYne>v*L6>>hQ;e@AsvH-
z-Bo<z8jHb&NVK|h*6)_WSGZC^>3~r<ZU(3W(egk-9!<PQ6tO`5*hao3@Yc?6VQt-Z
z7Eq9^U$1!ymep*=A5*EYy@9Wuj_A=BF-dUmx>vDZw7~iOk04U`!`hj+(rWhsLx?XH
zOjx!E3k8~8iN+$4vIbDX5xt|x{>3(5_IF}9tqff-{~LH?*1JsYpYDGW8X6j4J)V#F
z)h)kea%EaZBz;kEK<Vz^JOsbH^8vW=+S}oW@0TK95<K*WCt>xf^^lG~v@0rj`wbgD
zgwe}i{0R}%;_!=1LwP!QnTcB=6!276)xgYG-hkV0{+*L7`m&;e)=%{4#rbm368x1I
z5QtQU<zD#9J5t()6D;-nUB-$6oq3?u1Dcp=J7A*`Fkm1LRpwGpB&lwEA7fQyDF!2y
zmKkR_`led}kIELeBsYYDgk>1WOvCLBk!ZW*iP8O8JqRXNP;&4Wxk&YRb5Ux<(V!8%
zK)+bT>J6>b+=m~L`lLtprJ!xgt2qDA(tzC^8!70)%Eoe>fUr$zMT1gGkA%gzZRw6K
zuPYl@k^Ve=6q_`uvJ^N_qRF%c^NTQ0m^eHK#^JWsP~5hvsc(i=xV3TO{zZ&#8U9+Q
zw0u(?Ta{pij`l@WvTjqCb+xz(L#Y9;O}J!8s{;dj^B+L8LU7MTLl~aEdgi6V#9{mg
z2CY<3TDGAU1{?GY;PFMie&)K7E??(J_ew=g6Wb~h0bNFVwD%EjKMxZOFim1S+t9*;
znFf51LKD8LAO(NX(+b1GBY$R%buB!&%u3-t+1XeH@9tiR+u9RhTYVXPRmrz*WEZ=v
zU`YJ(I6FaT#$#r<iCm5WqzffOxTA>kvcIo{=v#hyjk#5D{!h<_%*;$E?$-xSJn2|?
zWA^`;3L%>n43*j0d=-PXEjDe~#9T=E>grlN`_Kb!z5QA?=@SpFa8Sz1;yz;q`3r*x
z5zNV8Ip2(1<R82@7bYKjI7~k72=-a>!*Y21;b&zsW!`DOl1Kvjdrl&ZHcLzJJ8(i3
zpGGV<8J&Q(E-0xcL#dybDr=2^fzC$IqnskCjHm6BAZa%?Af<uEcE>>6dZDxn10Io7
zwg_CL>+I4hT=KJ)C6B=s6$*yF#g&C=3)jL6+k>5P*lpPJO+^jdvSN$*xeuRCNpy<k
z;91Nz#pCRlm1;(n2cl{BvybS_Cbm^u>R|FMi{Q1-_%ClE_ia2YK<S!O`ZK!E7FV$H
zLfrPCw8tR+Yg(*YFkm}=dDh*Se1e*`qr8EUuEe0})@Rq6pa1*EdORb-Pt_0X&Cfv$
z=*6#*RGf8~<?CaA@g2;Z$5-!Uo9H$QI0VXUEFbiY1p6WEqvfc=v23hcRJjh$T=)mv
z%AIG^Rg%$@1rY=+&M1JRiuSVMso+@$w(?+M*>uVR01GBF6O?1DoQxN`sP1fHmdFU_
zOoXQG0Xp<ZlYPGuT4lkx4YxIN^Q|9_3@CjOUu_L<ciI{$EGpnwtPjl#G}+V2!RAd{
z;kqk+2_Ju8_ZbmW&_SuFXQ2`FkW@@~v2cc5j)7NSo&&$U`7U+_gtkle7&{6E4;{#{
z#BPW%$Rl4o=-c#XZ7Bv8^h=x$4PG;#2<Xf}kVH2aor~BPw<G?9hbiCPRfSs~8Sp9|
zI{X~rly;)*;dq^a=Q0-IVa`wRAY(N~GgI&|XEyyrz|;$a5IW#ljgi_XWt?v^Ze>vD
zaJaDzF}IBWN?;6ee3Aa^2h!dp*G&Nxr9#}|IW#{DPQ~*cLDH94ze`H+&`eGyuEsRM
zR(uj<KYT)EEuQ;WQOgIbAadH1CUZa!DEY}CNX_AaRVw}}8-CkpXu^}}n{Z&&sq=bZ
z>n`30^RrXnq)9zt>H&PELDcAdJn(n(*#luT_5n(7;(<d-^Ox{|f>tVK-MJ^^;UV1)
zpJ*WR7)YJAf4Hy$&Of>jJ79YJz6G#(S0hXsor_x?b?_HFOnmjp07vg#z|K<aX#`Uw
zqkqqI_|cKQAv=@*V9LXlof)T>KxIucY%o^q$k$WR*C!sp&z?ASM+!)s^xkE4Wv%x{
z5T~1_w6T(jEJ(}31DT`Y<lfdke+urV|8nT*4F9L~v*GFiC$i6?s&zPqBcEhENtTL?
z$NZvz!i<_Q?>Ja#nq>&EWEnZSP?8n!2#Ld0c#eVJ-}y)Q{R6*(ci#E{N=o{{*l}av
z=IOsSu-+GX^Cg{&7&xc|e)XH1;j0DT!tfD8QO<|3b0@zqXw~A7!w!Ih54C(IBoa-2
zK^|Or&BgG;cS~W>!o_%9#?S(H`PCP4+_#APei{7wuA5-N{I8*OM=7p+)IfShI<(TN
zp{Sn_E?qrQo`?jVk&x^%v(#p<mGS}P1e{3e$qPzyTQY$3CEghJ(1uc2iQ5ppa7q71
z7!2%*fke5qdhp`5GCai71Y>c+{W0R{>_IWoQvT%LeA3RwK!VEW_btSgk|wwx&rZ-@
z9UXe4)sEM2mEco6GvSqlE#7#;)7W9?QPYp4pkx8ADExo{&fv^+xMfHmJb=WPu4GxF
zoyZ?_k5HnmoQKFxEKkFFTvAd56Z5j#<k3>sela&G*f(}o)?tyl2kw{mJ$(T5I<A=U
zCgY(xDwmu$$WxZ6zbAo4B+LWRwEO?Q-VN)v*8v?ooQ@NoSmqbT)#K9&tGDo=ot{wm
zY9-(Mt;cPzhhEtPRrsVsGH&mY3`$~aMDVxuHJZ9RZEL~N*;tXr_d(RaW3#s4ecTF1
zO(=l#j>4zM`e(wXo%OH<gRk%LDHU3n-4~yB*+$!Xn22@|u2Rt9$)hLaGZ>wPpfbH@
z;$8IhdOS}-zP|p{{!oigiUdx6gRCJW$YD#qAb^I8!OFO{;zTY~d{u$xII1?npv>NI
z!;q74tmExZq(AO=D6Z5N0j*Yiu=@viar>w2$JWh*Pem-rrH@rB%1T8GK{+<@izR;B
z^BNYN#B9m3a!feNp}I??N`3*Pz=6`juYZ7HctDbZ11?8Ucwe7-^si7_x{Ix79D4YH
zP~5jSRF+r5m-D}cty}Pn2?h#hpL+__)$=W0S<;KozXog9tY<4Cha5hM9oiH|zxXf0
zZGeJ;d<;Yk95UzS<-$~~+fOe#m&vBB4LZ;nc50XZwULXHc0EosvAoxTcysX(;tmWN
zXuBldL@!e*##I7Z(TK&KX!X-m7-V*|=R2sA(}7j8cP9oxbVel6>4|3_gexwZk!Uqq
zeh2eFEbUHDFHn~(GY$X-snR(|^uj}d)hu|p_u?T?T$m0|%-#Yoe3<xcJ1_eJ)m=H`
zSQ0HXPI6c%!Bqx2@3eVm13UjDD2ofzpbFoqQe9^S1QxHLGOiLr?Q4kuS?ncmSu*C)
zr|*ZWFTGI$xuwwm)SxAJK8Z`Dl$D}?3M+ExOa%U)hbnw(Lr%elE~HWrIzea+vxWYb
zgk8U^(a1~8R+e%}@YvH2z%`fMVlr8H6Xdc-{11yDw2~B-&CSb!y!?DzDcFVEB7C))
z5cC8HrOHYkaI=E>g<eH}^0OR9+qj#^q$U)#LoWXC%*)NiK&6zQy@<eL3c$?6_`f!;
zHU8Izx>Ips?XsSz`ZX>a@0Tauc=(;NTd?zQX`>fMk;`MXojR-79&y$oQDx8l;zTLb
zayx_vVrh5r1VJ<vxZs##xN@3x=84|5Fl)Yh-#;3e@zTapcW<3E@Z+jtsbdS$7|6Hn
z<|`30Ki%ibab7~i;%ixlS3bxY3EI|B1`#Bbq9#g4Kv6|25o9;35zA1)te*v8V8<8A
zB5_i1LIezCQ1UYkhE9gWyg@J18RRx*!A0vB^!Mg${uG9w_2ef4({P>%Mk^%qYb8FF
zQH?9q&I6w60D|){ZSr{#Q3<<fR+3Sb<yBBwQH{04w)06ckBdx+w1DjrNVtsbq5#Xy
zowI_`yqu?V)=*om@<3a)`>&r{3;T`Cg)Dp;VKYv)^!TLw>s)19qG5sRP9wU{&Fw}z
zAdaH5PM&B_gi`{a>pV^LkP|78NW#?!Pnm8LID{BTALC>h4p%}<l$CJ=CxozUpq#0I
z^ANohOc2nfRWKVsRz#jRX8n)zOWzJs3quH-P|GF<*g^<yK|pqjx(Qr_tFVWW*$Q?>
z70PTm71GY`E}1-L#zo^FqPWO4AgBktT^>|I`_s`fuTI_118vprU*on0z4h{s_$J7g
zKE}gf(h`4rc|CC5#e@*p(C8S5TFIdVk`Zo%8{%&)ZEbiZ8qe7O)R3leFIpFznAw2n
z9u)=3jd4g}6R#8Io~IcFo1iU;R!-s<K)li<`^Z!GdQR+uRN`ieY1_b=h*n822n_;S
zi7+R3feUm+0lo^ngv7+;CCmlafrQH?(F2UW!P-~kqnDyNv<I{Yx{U|ib5ICXcMEkx
zqERDp<G{vWA02?-YtCYD?-A0A&C-Yzf(U~J--(#15yYI$Dj5<P0Kepw0T!^hD9y3m
zvPG8Rf_l><DYIPG>1OwUkgXml1FS>~T}mWpRHFoxt|G72ueUbTeu)V6cWXp;O`tuX
zJ<!=bAm&-cU_dB0SPf0I8^X}a_VUGq6pz8eDXnJ4@Dz8Z3{|T^3Pwa<oSMElw}OLg
zW=OSs&tOE<)ghScLLhFRn0hHg$w5mXfpVfFomU`wSCWOfkZJ(cPhpmt*ai)*j41Vr
zgw1*W1#+19_)}`E_JH<)_CN#=&<G!4lvkpaK%vVQDTuh<fTT31vegKSJN}$GkWz+{
zxT;DVCV#U4z?2bTTxN70^09KB!2~IkbO`-i5_g_Ws)APV$fBGFEM*#HK7w4qW3xp7
z@oM@?g2`Dop8;_rWHwt~2NE`S*bC%G`D4fGlJ<c1fc5}-KrtalF$TxxLWNFCkT23A
zqg)_ToQk5ZP$0q90L!crqb)blUg9wG+ryxUJQANXfbi!<%|xI`E<P7PVxqt$!mGF?
zYEPXu8Z3C2<|K2KEk0qi1#uEfu45>{K?S|F;qaEX8y$qYs6C)Ppgj<V2WZZXW#IAU
zvm@=L;6}5_g5I3voJD*^#84T*LWVMDunf~eD62$RLCnzn%R%HQN`#oDy3msyG^s0O
z3F)#<Q-CR$_z@}*x%gZFVLKuO&J-MbCZZ@Mff8sLA)zTt?+>9wuS=jROK1kyD-z5N
z{LASa38k~z1KI=H1Ku8xCKMu~q61{`dSKMVjK>FM$V}h`2gT60HT=vq2Vu&X1(vfQ
z0xqs35c3ouNFd5eMIy2i3yg@KJ{DNcd4OdS&g&qgq75Vf?21#a4QUq_Z7HHC7XdSZ
zsd1r%atDH3l!7l(6v2cbldma7`Nen009F2^Q;rAuLo_pPxr&i4U$%<jM0wPh5uFN0
zK3joxn1*$nj&-6k)j{M%{Y1H|<EWmZt*L=Up04B@;fL<#7v1js-sp<$9%`Sz8U2Je
z3hOVJr<;bx7kc&fbfe61S0XM+!eJSSM~%j@=O&(Kd?zEHQ6}8=n5SRS0>{cIhv9BS
zoREop*WY*rw`KHjmKV01c=B;@9pb1=S9(3Pcs;hri}H0hpbWHZ<?=N!<)mZa>gz9I
zc8?e}%*?M`u^OgKm2pGin(Hs)e26<?>alRm^vhX!<f!3hp7@kFRLF4n-!vH?*2(0<
z{K^$;48BWjGO4mFm!nLq&$TnKewc`l@>GWv%U9ul=;SymUpwP+I05TKA4(!G%Gb`g
zl-B`eo`^J}JQDqR-3?S9YzLG%bsG8FXm@HOBTsE~5^D$E4@Qq3iMY#|-&c^#X~&?P
zOIdm3=wW6)C=RO&#CI*qpuFG{WwMjoOm?ne|DE*O8RRqaC-PyQlrx{P`ti2CcKRiz
zFUT)%zwti)+xir?h(rI;mwe|;?edCjrx9&gRym<9^>-#+fnFEfnJT1h4dj9D-0q>&
zT`|ZgKt@|AFbWV6dw{u|fJjd=M5tboO}|9VJ$+ARqblOUmcOmnehY9+S93W=WN;cZ
z-tNdD`0b^Swl5q>h9o7?TUB|b9)1E}1%1V>7PU-hL5)==T;4bSeY%~@DA|D)H@!O|
zDgM(0!J2_yWp1pDDeUo-;Xpk6#P4Co)xU&{^i*iVw@NqQzh_V_wRQQe4f2cpv07E<
zv<I{Yv<DL40mZ-_h8AD3u_L)@3V!;PD<)b-q@dx<3H&xEHe(c*Y_g$LCQt=TB2FNR
z^sC&3lx29JIltuyJDE|k15K&)$frQbSCb$@M({)+Gtu-vQFuK~5X+DpW%5AKi^%v#
z$;E*2hezJB+YRI4k9M<1E7l&+9_VHspt%MIqL{`agEtW#6H{OiyOb}WN}z3?^|cvm
zD=`0xI;r`Qo>-*S2_^w2N4q37w@Ktw!em-JLKY`8O7ySIDba-mHG+yk%`Y|7L@P28
zI1o(~DfnM?=|9S<RuB|IJwfc%=p>Ws;E}r2iUd{DyQ&@@&|vKW?E&q9M0g<37;a29
ziO_G88ND8wIF#dQ^rCE*#8Yrv#4S|XDJx<VxeXu}BIikgsl;%A4aP;-K}L!Bkt{a_
zMAqj?5ljXhjC4-?cH0~Ze8losqx-)iz0<Eq_|)IwDP7ba&>qkpXk!o1oD*@7QV=OX
zWVr{JSBj97JoWi<b6$glPePu8A{fF&CFa}PCV>%daO+13gNRM)l$VGj^OHo0K`2l#
zx<KOH5#m?9LW~d>(^V)mnAzEum;||*cu<0_Lmi|>WqPL!Bpg0-*IYxi2eb#Y2ReWU
zf{#@+JUgfrpg>jf<>N?S5>jH!8WHJ~1`$^x68cAWk%t;0@jzKdF*!n>om!}{LoHUy
zDRn3q1;`9sgcyMkWj|$t#(8zhFz^IU#Y3`k@*w3TzDV8`h|syh!I%wRyEZPiLw=LJ
z;?p4w)JAC!Xb)%)I6T1Shgc>Fha9;WzqrT}l#_;R1mz=(adN~}cFlJ-fUV#=SGczr
z?7YHAC6obq#VPAaBO_Q)=1I-f3ADHhBUIN2G}Lx-AVK7w$rs7F<i0>vQB}IbKK>b?
zexAP32<-vw0quc~<N-FGMI6*T2ozui$X#7uBKLG^3P8S;6kM#9_<g8tbR?s-l^*>J
zJIWvn&>%LGnU*p&tzhUgRhk(_XfKhu`1@IGHAtd(7O9;K1`P+}qo1wKR7o4By<|ff
z`m9Gy?bvWj<ev1@6v)g-g~p~9sB37#M^!znliJtI3VQtW_8aeDZl@~O)HOmg$rJTA
zWOTR{39>6d{k-a};URi}UP7f)_wzt^Zudmhoekw4<GIztJO~tE1;`Q;Fz1v(FRJ2m
zHIBfJL72Z7IiTP~k*R(T%XXT1Gs7&Ql7O(QGZ;bq3HU-So{+-SBe+bAL4y~fk<gTt
ziWVK^==~AwkJEV4*|}mWk)E_vF|9jWSP~h)2(c0&yGy{BBvS?p%_QL=WOMU!;Mgfg
z!MO2zMkS5j!gU<-5ifmGQYeCJ|J0|rx2G-rOZvj0M;yfL9Wbb*{f!OT0(u)?*eRob
zCM4lwNji004<w@9`xd1sU$NUWFBOUl(mkC~l$+}M5$Z`C0wR{W=VzrrpZv67+8txN
zmtTSibBJ=Y_!790;%%0;$wHE<3MO)rGoc_Q%c2s$R4s^St|%>sy`R97Ktk9@3@X_n
zCaH-sGd7eL-;}A7O*)n_+0Bd{kEOi)JSgm0XoEYcc>qCBdlGcwYRAS_B3X1WlD|YO
zHW@OP+iLV40vX(a4E?ZW-+sk##@W+g-P#TC-J->^U9P-r%h8h$gNgf%H)%fo_;aYK
zsWr=Oo!Mu<32^b{7huEi=<eOOKZO6j__}FE&z?o_tGjMC%Wutj7dEcnWR|;Q=AgMp
zKys$lrE1sLz}KhGW3K3T_5c`k`A|sB!$|{|##Y_C6t@0%GxR*V4~)5QoXcHnA6^NY
zo?GXFYe2{Iz`)+=aMdaOVbbV4ShleSF8|X?)5y~f=?NE4=?l3%QmEPCp;tD+>+^Op
z{JZy#gES+ktf+2+C*RltbLQ`6xKSlN;7?Z#hphBu#`lN+Y=k$y*k#J?2$_PMRQShD
zqaZJv_xasbP4M`v&G61wWz4*{@7@bC(SDIOme#}h_bg+@QxCTL<&Up&zZ^a;4}SBL
z!GguSJ~d}6{QJWlUh|+y7hQ%z1GZscXOn+|+A(a^pT_N+luY=;i1VR1BcD-huHOxR
z-})geC|||O&+T~)<fis8xtCRMf?HQT&&r1t>;V__Jpy{C=ixGW3;c28Y?xcN6vk%{
zhC7F!WAcd1V;kOr_jZ3Tiqe%VaR)?<z(koDlTWU(2e(OU#w)FMIS)O052U8@cCW6k
zhMBL-fq8T1n|wrVCgD#XWj1<b^dU9HIx`di(rScIM|iu{28UCbQ;@+&?~iaME6B9t
ztWn>|k)X0&y`|*2XJ3Gq{{1Ta`nR`0j~<y8q8)M>nHgpfQC?O7`2~4!%<)IUqHlj-
z@3<$E4mfBZX4yAiErOT+^(xf1W6+Z*7tNXZcGRLb|7$&L#X*r$OAYQNQo=?bI(;OR
z{%;$s{=;$@e%ojme#;ox@zyrj{pn8l`Yax75NWStieb=Y!=Uu-tyI*h9Xt?iyFWdB
z6jWkcSJyQ|sx<h}fOgf%{o#Xe%ivG1ZiXArDuL;zm%w}9>_*xaco_T1+#f1fpm6Jt
z2Eg^FmcUzImO*oKEByZAA+V#Y0j58>8t(h~P`K%=0r1hHGRBukmqb%{IvD@O@=EyU
zdpn?_rildrH=Hp5-u<TB+?Rg&<5HM4p9fC0SZ7M6Ulx|34>rRMXO_VAr*Xf`Us?%2
zy`O>&K2jbzE+2k&d@=fr2PaH`^hFbn*O<!4q9Ax<);lPR|4AwwSuT*?E$~I<N_cba
zw@};M0GF5G|Jo>-0za#G9Gck~34niY`55MwFJ=7oEsg9-(yuHz9^T&dExfpG9-P<r
zP`G};N$_RGYFJvc87^P?4ASvwbYjj>xNN|&@MR?rP9oIQVJ8;JF-(-m;8mVw4H9B}
zYtDOg@lHa7VcW|uz6OgH{($mZ;k=)m184o{beKQyOK54qF^`*%vPhp5NHTkb29rhr
z>{n73ZKBnPRC8OygF6br(yeR?V=&VfCOC2bMm#4c8}5DZ4xp_L`X?)oJn$4WH8sK2
z(=Ub5dyHVw9F>>+uneAf_*tl{t7D&*W@GZPY-BkvzD%6-?|$IduzOb-q@|@n5iT_?
z`21`5+n@i%_$Vm2=+g6H&%H)7oz+#<@W_KtvlWvudyaw&FF6<Tafzz2u@UBe^f?O(
zCLOddTZ!1Pek0s{$AfUzk57f8k3AfYKISmkfU6F_M}6t(d^vW)#JymTv7=ztt8c;k
z|NGcsb>}Y5jv<g}C~bhc4YknPWZfwR2Ngk5S~9G|NujB-3D!Qm3VI#e7kW+Z1KVET
z0<~*uOh*+R-V18iRzv-^dK0EIZR>$(+x@!7R>AU3weaM1cwbAS&jF)z*ownnFet3T
zAmfSITi~b(1#rap0=ByF`sdaP!-wCN!$D*6*cJi(tKwdHY4GUG%}|aj6~%?=xC9O`
zd19ftnvp1vL{s;j6-{v0^BYW4{_);+xcB0rFsdXImf<}>X=i04Y{Hd@CTUnZU=;Vu
zvxZ-uoWuQc__zXibHQ#{$ND}W@elq{F09*82iwc}L~JSxF(cL`-gq4Y31bB|lK6_I
zTKMbc4^6UJrC-CO{E;vqy$IIT<H`x9@}?RnZK!}|b{LYAj>#^8%#?I^z4S|{ZK;P>
zwto&&d+iGoatFiw@|Ccy!3vo6%Nq`ht2ROz%CUY4b2;+2VqUY*+>JQ7V}|7gz#^d>
zttb=58nx_rRx$|a^4TY!o3!72y%5HZ+XD&<3t;C??9)sImn5%#*d#I<3F50*qVvd7
ze3Xi-dnwZWXBc8}ICWYWTTYOP7g3o=h7ed2$}&>8WJknX>e;IZXp*O`fl+w=VW0gc
zFp<MX3}KV_yiXTEeSHIrn=lp*IsCwg>b&@p@hnAVW+wFO-xt!-)0mt|2k*xM3Mx<#
zF@Eo{MqscBQZd+|?U&r#9JmJmyBh@&YgVnpNU{}<!a#unhT^_`m>hyrTE3Jo)%NUN
z1Qh6O+qwg4YwH-Ux~hhiE6OWbxhs9ea`0@(wIkr*&yR*l?;i#Q2NyASH0|PpU>Z&i
zl+uj-<cxmym8Ue^N6*<K4>rGG4bF@~f3>LxqHT8yB2;O2C7(U>dhmtM{49R$TgdwX
z@l2gm2)Ca*2yQr|1eR>5fi1flU|_EdCT=NC##fxwA8P7bpb=Lo2K4eiOQF&q3oP2Y
z%Q}w0)dM=wzH&1L(gxzPsr}&Hd&k49yT-z#F*ytx*)M#sF3d@R(F3yJl~4GJ24fb2
zCB+JmgvBfoL?9wG9kw(lY#(|RYGUqCXuyADwF$R4M7nC=6nJ_3jqvoC%VCe~0SsK#
z%==1q3UA}=R6YjuO3f2&>`GfF`{oUUH+Oz*{E$~qU^XVdg2C=3h5mafB`>^6^udQr
zf}dV=9-MRTnK-Ad=Rt%?NRsg5SOGE7&Wu4Gl>w3rnrBn-X$@r(vXw|XkVr+M6%J>j
z>bRkJHp596R=EZDzHYeYc6j-PnM~wf#^K8c?|BqfuUw12=+mIGf=|A~M-GjsHWDA{
z`^AhqVd>)KOct#`P}=MN+4~N_s;cDgNv|X%fsoK42_Pcs+ORiJ1bZ**U)O>PD$Ty?
zs=My0Yj<t??ON7#*WI<O1uWRmRk5KW9Rh?NNCGK@^nCN1d(Um}-uLc%d4T}$B=6l*
zX6DSyIq#mibIKjLmt6mF&m-(zc!+Lbp636&h!;tY660dS`i%sa-lrdZE^vn(c?e}>
zXp4s$8=54qK{p!G($lG_shRF$THk#2y_9|S$rqCT?wcPZy*qt{yYOtybF1j*3Exxc
z9~Oy6V#wWli#qDqUE5mUOvSekqugV9Qpr8qLfk~h0<}ID^_TS%o8I2AJE?J(lO^1C
z_Yx2WMtxHo-Nfr-jvSFiw_VszK(jK;8y>t6hjUpnd#pbFsandh_5cA3Ezdln2i^JN
zD%r}GZNU?OPWTE}cHC6)*}o{0#vPnXPjlaeQx$oCXAi~Xr%LJJ*VeH|qMdHNfcrNG
zr58-s9Ko{RdV!`FO+F0M+E9HCd*`sO1YQbTa2v^O0FflxwO5IQaTPr4u`jzUO5=5L
z`3KX}>pn2N4}ahI8Qrk#MS5uUTh!d%Lf7{_NvN)AsHE!VZS<>x<7i}Nf4Z`_Hh?R`
zLREcy&InmQ@pX;4-bR&0e$`t`zgX#57h76YV1+T_I>7J|!}vjXID5hq2~*t8pn+*V
ziI6m{$N+YJtmV!)!@?WkHt;(^gQYbd&5E5K2`Lf7NQ1P}(tfeloDRlS6;(Xd(8|B4
z(&a0K;(&pD#dC1$Z>Grrj!X>x2<hqOq8!O^e8J-o3J;zEyr867_Y7d_A)O5ZSZbI;
zQ41jvZ{bBz`MTEuo{ULTt~6@Q%IZdSJpF-?nx<LJX*z$q<2ndK@F+yqK367GYUXa`
zsfi{U{^-7xIgItmhQ#8V=F<RPJhvAwtgM}1O>GS=)Wj}dYv^@GZ`#5O@!I$aG!}Lb
z4cz%c8C^N9fbO|uAT8p>w+(DqR8+SZ!rlI&)@ROV1M`}b3+amm)wGp=p9sIdY#@C&
zcMHKYfhm*fZJLL}K;8)vb$_!~J)l<#J#^I|Uc*sMuYO)(6v2={_-Vy9+QjQU?vrVc
zG%+N8qxABB7QOIPi8Y)uDv!QdQcF#iX+mpx*l`#JZUWc{g#<95L9QS<o9-<-pFIaZ
z((En#0HK$DQ1z3<O1GC&6&nus7F|I7Qu7Fg#2?DupmXyNqdNzlOW)Nkr&^vS+1jGr
za}{w+cYL~a0UIH$%(8!;6u#%xN(ynsumeGX1s3Z$4Di=KzbN>}jX8!+KkH<gKW_nT
zD&K69<Uv=_0eKY<r0J;KEvb-Q$}r$#r-q9I!38=n%Oq{az^v<H%RqF=>98STsoGWr
zrVbDac^Ux$(*dJT<W>DVu&-OYf&Os!!*tepr|@*bQBtnHTJ*`pT%H=K*LOkq!IQU~
zDI)q+4g6SLo0HpJ)={7cmK)YoAYdKDTd%(-aeOs4Hd29ZWE2k>EcsXifv|a#d6STg
z-TW(@g=bDxwDR0ALTdkXF(kI~d^kP`DSYESaK;f-zudfeWFL?tJ37|=eYL>EzIL7l
zI@0b=uD|8Qi1;92i{yXq*o#(d)TRZku<w1hMGT2Ud1`C+&zff<mAw=XzPgUGczY#0
z7Hc=#4Noh6G~&3IL3Xcunp+(`S*E8amxz&c*Gpw?Ad*+NT{D9E<)?@tVbe?ZB>MO5
ztd|X@UiK@>kex37o~;=p0faFcg~Mn70ec39ym#N36-d&vo_5Mk$fWy<E~Fo7SJGeB
zeQYOa!K>%B5C}aJvuO=g(h^=&`P)^mN?!NG40?X}B%Tt%y+K1NN-K~Z9axYlLFDYX
zuqFi+<NEZd*J4Wxq{fTM5XUt9Z|8g`hQ!_@_7X!v;TXg%n24I?S^=c)NPrPxUmKxO
z6X!t?!cIO6P%Z$j-3-!8frO8P>4*&p&<Yk(Qj+QB+ow<=pS6InfTt6%CISHqF)_7p
z*pZ_oZT+gKsFYn2lO|sw+ehd9FrO+av;im>o|T4*!??iW$bNjr1GZ{@|ILq7R5Fm>
zpYbux{q83^>EzMWr*Cf>b@+i|B<#J<Fxt3&6TST6zv=vo&ysZ)4?KF0EEomNPj<7#
zluA$0xTXzCCl~`2vo=vGZ`~`pb(l<3)bJA}LJn^OtXo)1@hR~%{PBHds-w#C^w#%R
z1E{sGnW~*`+-NWtqtU4v$l<AoTs{vXo!b^Sv?4w$1Pc-2Ss2A0sl{uzQwpypzyHdC
zGS%_b!Wv$Xm`3{-XV5J6UZpYKb-aBPVG(;D%C|IAMNKn5iMKI55(5J+{*QR~M@K@a
zdseu#Gg9N}uhU9om&ud7Xt=0Q^Q^9~Y^0uS9Kaa(gcp$(<|Wfq-pv6Sek`q%Y7Sw&
zEMdJQTlKQ2#$e&1WAkN!>RiLvcHtg3b3NM<HE6g-LIAoJyJV)tC)54K7f=&VTl};9
zOX{7HBh_u@#g*N8+h<970nM#lK|PYPcpBqanWk9YpiNm0=k*e+8!9L%E`g@@KUt<a
z7H(T>usgoT{#4miOUvpvD)FQYqJovk11MPasNzgjMLme4Sk>LHe_tvYQbgZ=GnX*V
zoq5iwf>l<w#>5tH1Y;?>3fY7(VhRKqLBI@nYXpORa#Di1w#8b=aWN(wM78>?wK|YE
zDbpG*AgIqJ+yAZ&H{`(T&75u9>Zw0ZXTSqdTT@5he*FVAHZ;<S<BpTXj_3dKEW!ds
zG=w$0^3rQ`(Iw~7z`_0LNIvWdY`^mN*Fxf1X&|mV6wf~KJWaWIBK2So2aFd?r&L$h
z$W#Z`Z=A_zUL0`Heg^uy9~Owg^ZcJ*re96C$S@+XBLlln_N0LMV!x}{lXFw3=$2vf
zfsWc++i3Z{i+TD&Gamb~o4OmX*hgsPt#b3P<~1dH2aiulpzb`sy#C*oAEH3UzIKKN
z!fAK#hpCJ4+<q!NH;s2O&8ZY`!o{QWX~e(`DXMR5rKwMs%IUh9>G5<mFQlA!ie^C6
z@)P^ZA8(?cS886WJ9*0Ev57_W?!6-f_u<#qhQ0MO+<O)(g6w`hGJ^_IjWZ;k=0(OT
z{PyM5YzVdRR@c7rK|U5?KJ+R-kL%MHUU~s+3VUA;;GG?Bd};N7;>QwPqR<ea&cO|k
zN1T&R9z*Z)Hb}Q(4blAWmD1ffL*mgPmly@VUGW<4)~KWD1GK>v1x>v5^FdxKft?-*
zr}j8Vc6cCO)m%q+uJ{+%iCX!1XErX5${tRyZ2Cgd+Lt+aSv8<xSipitt(Z>0I2t?d
zczp{fQw>5GR8skPf>X~JCte6ps^_upgZDn76{Rb+CK7yxlu=x-H_k!SkyIQxx%2=N
zaA*bFJu#&rRVgC+RilM(oEBmY_LQ|m#f?R`Dnq}z)q|pt@7h3>Pe1oCU31wqos|Cz
zPN(d_I~_2sVGT0v!GvL8gcBmgLmk+LiuDhh$}426r>YkU>zSX&4G~Y3?D@bN3KdX>
z9UREV_Ru{ogxl`$HsIt+{19aeC@(Ox2269bH@8uv#f57vkHx!&2EuLkP+a%rT^P-5
zSi;j_4VYpq<efTLDuvw|&VZX%|DGwdj-T+Y+b5lHNQb^Px?u(8J;nFBi4olE0x990
z2P_|ZBk+4z!v-~WhFOEFUTlIOp>S*kRx(;#FAf1^$Fl(Af$xcD|47$gbBn-OicFjk
znJAX`Uhp{*@HXTobrbF@T5wi~l0zfclRXu!y#Areu{Oe4nN-R5X48}~ArKP-gzM9&
z+v~7HG6gx)!Bq%)^vU1Tlu5VgC^{VnIVBsi(RXwCP(r-NLbiMgris9-7PwPlFN1r1
zdPRI;923pV4iN(i#-}uXrv_foh2M%ZV1aK#V@p84bHdruOb4Wr*vpZ^pWi)r7u|8=
zT?Pp1t>3P{Z^Ovt#h#Y9E$YITt=vxni!Gf-1n_EW!!saMU6JBRoouwY87}Z#z_@S=
zDBHN9+^uMj$n*PTrj&t2lGZaJRKB`4@M61I==vH6x7|ZYgcBXz0tVJ~y2r|`9Ai(}
zCU;ybd^GM=ie5Bj$0AAXObA8Yes$H0j1YFXa8i+@^BM_0OF;$ybWBLZRKOxh^GpbR
zbW(+U-P~+W<5;pIh@$mjW@x8jc#X=T`pA1TKeE)VL*wEwfB+=fFd#NpI&1(-EfTe)
zE!6D*;6NY0QHBvPi}oy0JFJ<45rJvMV8>zmsa+_#0K&`R7Lbj)oqDzz5+1m2^kR8?
zfCl_dYwQ84*rP=3>h0c{_o-+a5)pSA8JnFqYsvH`8KT$~QOA*|eI6X%eaAE;03SdS
z83-X7AOH`Pj02%G5~05Xsf5DO*wXZ-ST%8iGwrq5(s<N&F(^P=tIe#%jA=fUKt4<e
zd(6V0B`Pp3L@<`iaoBbu0Vx^t19J5YXFUpz^EG2ZWdvS<s@Ostz86u37fqDM!k(!C
zxVU3s&(lCxYIoe1oS)8Y5ln4#ji7GRR&Lz#Eaf4JEs$o^g7f&(_nG-&#Vka0JlCAS
zOdqvGGBRNhH~*v(A>&O8QyW2pH>%M;6~1OdXbAWYf~ru0UlkF{6^kLgrZfy<ZWUW-
z7;r8Tuf>)C72`ywt*YQzyjX~7Af|zs26nCnV)r43{xRs<lwwObfGtVJ3;W@pM+PtI
z0c@Zu*G!!Ulm!dHa0BoZuorha0*ZswYaQ4Fst7kjMp3TJr9LZ{);Owgrjh4D0@)!0
zSbz}`>HsR#DV_!ALeCI2hzZ7X8*V%URr6M$+>}5(5+UfuienmxX&|P74r@SeY)r-N
z+F|0mBLVY1&C=NtQI$578{4(!fJ|iAGwms`9GDYTL3S81?!l@PyVWVihFgI>Pm#bi
zoFLu^-mT#$giBk|42GxpR<OAG<Hm{+i^nt&(?CoE9vV<L8MmtkN-R5=25e)mE#ZyD
zU_K#r8mhG{Bpqu4T<N)HT4-=I5QK9AGwn#$6j+N=P*O&Rq)yG1C}+Z$P-VhD7K1`?
z>&Fz#25M#p#0+nQA7e%F5J1H{L-+veh<F4y!_&6d(gQD+9n(Ne12GM_Y9Pq{#uYx6
z8G!~c_85w`CA^9G1hWrzOb&RsupuGNZKGZ-KlHawzyj!(6$^?bsxi<p8WwVTREZVH
zZ6Iv$91A5q8Zap!`J5}2Y377!P$+z5cbI8aua!r5BZBSJP&l}PQXn-egiD+eLQR<%
zge{E43<(!q#<F4>h-n~D17Y8k0!hSjx|jw620h^qBZOs?(0N8qKp*g#X$Rv}*b6yy
zCZc=^kS7Rzz(Nl9V4>voI4>Z&#-Rcsgl`qI(BNDxWp5#@jc_{-+npy6vD5T~v(^^^
z$BkmlkO-#PSXoR1d#DE7ZWeo}D!PW)7;8e@;GK+Ob|NH-0N7hwI~CZTr)UcsDxt2H
zOhmO{$@Izz1X0M*y}HQgR)L$uraW#K9mr#zwEFm4D$%Dt`1}nO+6}$|%YO`-z;F4~
z5fzx{74Y)$ga|BPl#qP}QyYM@>LwvKyVqTT<m@>o^Rcnk4~R^?d6E!Yx};RfRC>s;
z;#e8$XIIq=+EKMNdVz}L8f*96x6eD<9Y;m05BdSh5ti}q9r-G)e($?-8Dz1_s^YjJ
zC|P&9>_hq9decO?(;K|#X=w+SGTicqFy53KCvq%KYrj)ZG}4oAxQ52@JBRSzAp~5<
zoiau~NMAo~f(%^Cm#&bq>!(hTfu>~0V7g9^t1_f<lfZi@uAh311@8n-UoCv2>^hEP
zfYb2CXlbs?DC79@WnAC*F?8(|jV4~8crCxBS@8H(1$gbZytSF>6f;eM<H~_I7I;&y
zVk&V)nG+9b;De5Og}932s>*RKmHI|Y9h`LKQ)H5|V&M}6@Ja>H0^iV!k^ynIvg=sZ
zI6h&tbXl3``Z|^YJ0nVl3}Sg$4;(LDR!XDC9!pnT^D9mh4K5x?mtB3S@Vl~f6&-iN
zF-Ce&(LkCo=`yK%`BI&isoI;ag%>?;@WN>r3D;bAxzGVEgimIDDp&Od0~M!cY6hp4
z8&}+KAFE-ZU~SiEADL?-9!qpt4aC~L%QlT~#&F{cH$?N8=y2=a+3;Onc8qLc2Ep(^
zi%(#uv`+JhXYQlxuDY3zedbqp^Xm=dxzhvBBb$dhKJT25tj1ue1tX#|%p%F*@<0#+
zH;#|mwgxAtHhA$j>huahj@VWxkMKDXQ;j3CRjzrJl?`$fcktmd4*M5^9*rFw->gxO
z8H--qdF=vB3COBwaBVo<GCo0HH^FIcOY36DW`6NqV^gbb&=07?k^y=t$vAdf)AVou
zXg?wwpm=W#Xtv^Pd%f|v7sWzM12GNkP8x9DY<DNw_IO!*%~#m9gki^TpJ>+yWHBN@
z#sk?S+pO3CFd{~oJ%>|WWW9vJU`HalqH%$ofx){Z5SDXb81Mz}t-_mPVMyS`llWjD
z$1(G5{8F@Lenk`vh<F%HYz*KEqd>Dc+&OWr4^?^<1mv5LF+(CiIkAkG26i0{m_OxR
zhvyil9n^q*B=$$l4M#i?jviz@?OMpX;c~G@wuxu}7!k9~7US|=#F%hs%VsQSWrhhB
zFd#z<S_no(!C0=`PI3ShUe3kY?QB%QLcojA#Gv38;<d2>2&19}Yb@}xL>M6W@LyoP
zOvTB9UY+20lqrr(2~|#zmv)&Tu~<w4F%9f&4TSh@?`-yB^>?ZUyjouk5nkmcQ-E|r
zxeW+{!2?hLd_aatJ7~<nGa>?RPX(o5D+C^bQx+}P{o7Mcckr-s-TCmJtI1=9R}yM$
zfOk27N;e{qE706V3Hb1QM-saO45I>`3VvB83=F)Pl+6o`kSJW$!&KWb1*6g$i1F=}
zuK*a$2@>;2DCNYiF%5J94S4*ty8ve~7IvNntb>c*Lu6p^&yip`aa3oskeBl#WRBk-
zZ6`@!x#hW0v%_&J46lU3g$RgujR0<xQvGq{gvRL|)_?&!k*74A1Gg0haTpu%?5RkE
zw<0M?42xFwRKTccZf#*5K}$+gGC`szQ6D@VeAO$la{%gY0Z@uw%p>8Zp;%r_1D&n`
ze?QhvXCqd@E~5dL9)tV1OSYRx2B;AMloeSG3g+{>4HV!38OSuVg@PiZ6=~lFo)NK@
zTH;)8F($0sS%8eFNi7tlff9uX>O#%#p`)BQ@iEnq$ZH+K4YKGmF@e`fU|mH#@3P=2
z51tA!4GJX#uDlo%6|nBx+Tvxs1w0+VbqnCeY1qU(5^kD`<;64*MGb_18;D}%F;csc
z2Gq^pA`-H~?O=i<!+}A_*vjWNN*GWa@u<(qSpb-kVMK(gJ%udJF^q|D1rw5;_XT#q
zu%U2CIO<~{1I|$tZj$NX+z2e5j3fX{TYxDsBy`TfH}q^ZEKmd1U9?hTbDMZLfQtYl
z1V)9dpFoBSJF)GbP)sbuG!SJCxct_lTtkdpOan>-+}nI~I2#BC72Y<e1`BNYlpPzK
zAJ6$1bW|{7dQL!wg5;}gku<kr27nqFM#P16E|Y(?mC{1rD{48&$p!*Bu_d#E0jmwP
z!PiMh8526sabZ52D|9DWPRmxzBy8<8b>#vUG>dHop4w=mCf=@T4Vq^HIbeW4hEbvN
za3y-|sXx-xYj2jd7%(QpQ^8YTO}woXTT4~wxP}#_*mbwl01lywh0q$n&)oS5jn#D_
z)Im&Lm&4BEY?qZi$bjUjEgobQ8U~i}d{C8JP%uVWK!#DGM}h#j6a{7l<~VC`ONWPL
z|HY0SKblEKGGOa;1T_MD9o@KrD8V=%1_U<svSR=MKmbWZK~#*14h2ScBLVYD`@{MO
z7>+y*!bT9bnc`du*+!}xlUTUf+|t6vNHaAwHnGQ|iKjqdm_Xy2)?<c*k5=kGpf8Q#
z)5QAr@8bh{_W|jQn`%lys_XAHxkoZdnTPtk@Bp6DJC%P2fj_uVG(D;cnvGhVpP&f4
zU}0ypdw%z1>qD+@tpvj>$W3y+(dK0(67V7kyNB#auA<upT8qa)rZu>5+^Hw%c!9qq
z8?GyLXQqbHJuy=TEN7`R?WCWRnBj?+o0KW8cPEYP#B|ExPv{UR--+Xnv!Dg}g<Fa;
zGSjJhZno?F%t9=@s7@b)Jl?5cX{PY#=+HtAL=XuQ#He7nq{JjjPfelJlw?Z6VPzaN
zg9An<ram;Iq6G^$+xhScId`O;!t}!g;bb>1I%w1{X!ME4(0emJq_wNp?Z%QuN3<R%
z^rE4^A3;^KH_@W$KMT=brxwznX(g19nMCb82e<L{b+qD-OQr0vua2d-B+aI6+1f;_
zo+zdAH`j;6D?GO^^}l)$C1&xU!CRe5?_W$CU(@h{(ex{2h~J)HGJ6c%@%wkDJ1*)^
zUo5DhUq8P}<UZ-(T$;pfpP8D#F4lH>XHF$O_J-C*?{ObVO*Wrp)>bsqFYj9t67TfG
z^XT%i1=KAq0nJX2a$kDut4hI}b^ktm1JqisW?KtAJ97ig_<D<!b>`R3mpzVV-8aIN
zy`E*Cv5{tcW6JK`pD~O(hH@kw2(~Os;(%_0=#If>(fgG@(bH?*7d0P}J%q06Glue#
zv#6o9iC*9IHT}E%3)(kxAl+Sjen3<FY0bOzVbweum0dzt_8x8Ey;1QU{b$o0fj_eQ
zFuJ(c5!8cew(<b>=$e`IMYVPh`N!UqDK&xb102d5x6+FnX49M+lsSYDh+tn1cuDe?
zMLn6_GU?Vkrc*|SX0+7S)Y6-8%%tzW`7s#bu*%?x=&(1!QX^~$OmhSc3<Pm8-G$vB
z@J=A4uu;*{!Y5hsS_yMXM2cWqh%pf}Bs6`*zFjmh<4x_R;8Nt7m5`o5C3g;!f!zS&
z-Z|)oAyo6zR$6?+&s2DRKN@&lF|B)PH8pN*pwd4sVWXpharhkjyY`~NHw~dpGd55=
z4?LcD<qb4wY6(@$Di?#K=(eF$bn`IU{9ZY=Zfo_X+2a0d!Vf4GGz~=3?&&G<bmKXF
zWnfo&#Lerv(+cV5mGyMT3#;htqk7PUafS5HPbz2=8;l6AepW$mf2|n-+Z(hw*I;;?
ztDD#`=}n*fxRoAfgJk+SeQ3&=edwbfw$L`lfBcPgV#vV2xaIu5H2L&C^xk({`6lSz
z?uu7+-8E(3s>{A!lbwaR<vhsVo8J50MRsl%ZOG81Rtqg>zV(4pgTE`QG$lTXrt}}D
zAD675f%esXPoy7fSJG2#ARL>s4^8TS63t>mW6`#?bk)LV^zl88e!)h_ReevO?`lhh
zrwM&dpr2}2(bH?+r(<$P(8PWxvVrk4ZEdNiYuLbef6F{JNaoN*1&7m=e&gtSuA_lZ
zcKj2=&#NnA2HNP-!eePt-?8+~qGhtO!4$^(SN{IYkA2%5*b%XK;S&1rgHLH&-8TBw
zmA|BOFF1pK`0giL|2OLmKbDxtTEq__3IS9=t6h7Kc_2mor=j2!fT|sy2^bb~;1zo!
zU{s*bSbtHSVo0R0Yvi&Czog+KhVmZRL{at=5C56UR;{6-{8F#WuDY1Avb#}ZLnFQU
z`b_%d!_VpB%g(0}`|L$&>8Z56zJa!H-%h!CIrNXey-FL_ZKNqTT|;ZvtfwA5@&tFq
z@>TTMgU_%~EuJ)c=J%l6?wUrcSFNQ-9(al_yyP4@=#c&C`9HrbFR%IiLwC}as;#{3
zHc9IGcFtUS;V=IXJ)U#H>2%ETM^H1LJ&OAG#PCi8hD7o0dr{q@T1xF}x)|emkV!~S
zq-uUTYHMtxs?RoyA(1vXT?~ox*R>~9=(u9mCdxUy2POAPrRK^;Pdwnli&6H>3Tmls
zp;eEUQjakO)Z_SkDt~JOdC_cKw_U96J+VFg${fjHdIK8~OIWvk^0cQy)Rn^Rlb(`5
zKP<1~#aZn#$ia{pRFG^K5|y>hw2nOyd~Y&BFg)PG<M7=38>z0Lm7aNL10B0>cRFfh
zcY61mDtdcPl|kpzAFFB9uq?{YPNEG}n&Dy;dPH_D**EI4XS3{ETx9R&Pj>xLb;euo
z^MGS|h-9QtqlvCB3?A03iwlpG0lZ&o4}m~=63@3|`eA<EYHH?1kn`$RNm;Ly?zET<
ziSnkck_Mpzx{am<b!%vA^EOI~PqgE0TP<(}$=wMbcpToYm`mH+;Nkd&#^vo#BQyKc
zH#Md7W%UyMX}O)#%jvk>eF)PkRV~}Jx@=tQS(eLtGe5GVf=6rE1M$)euNXkH-v5Lq
z@JqD%^zBV+)@(5HBaOgN!C_NYJx5AQ@R$~8@)1?;WGodiSU^A?xWV*sJR6QMDqu`B
z!$YC>olY?%U_^}EZ*MtWYYk5Y<oD`H1%<t6^X5vr{)VfWnRu$+T0`00v*_Fl&!F{d
zH&9MawipN%4AY}$o>)+Dt&Hb+yT3j63Z<r|QgO*(HZU4QP`thD7YFT2^XDz{q*+^A
zCwMSO5W08ImULQLnjGE%nuWa!sJgmF$`3j0Kzi$qciDJorsKvOC3!GZ1`h5o@jdMe
zi!H-3CbIU;ro7{O()Xu+Nh4o4$WT`sKPgszR8IY_97M_asg!$k4{F-fKwG~uZ~DDX
z>rL4Q<xt+SJ*jR%HDSO<@WRU++D*!nvXZEAeFG)&V1bZQm?~F%IcYY<j0i(F!6H~E
z5YB))VqiKQJu;gvxOXu<HM!Uz-O$uVv*%UQ|BcC~9^5`hjL4$R)y?$Hk~#zCs_}({
zPwn<r`rXTA^!4I83WitGJ56x2(h_MSHB&Yls0al)=DL9Khvd-yMcwGAeX?lLntI<x
z1nBHKvbV78n(H}G_RJ8nV`Siuj4Sx!5C22<nQza68q9!Vm%#-9gVOTpguIb7Vey~o
zp26oDIL&P>G-LC3^vlAd#V{Df(;Q{nH?a|6pBBzcNTUO@i|C=Uw*(h>Gb_HQiwcio
zylyhhv3mPvT3o-L`ljRxOh$YPRZ$&fBxt|$9*Nq006dQBHiU*{^rq1{Bk4OfE~=Vq
znRkm}WN_$+Fz(oK$5S}Qgq6a`{YJ=Gw|-r@H9Mj>R4rRR-A43?C~D2;hg>Ka@CMHY
z4!#0a-VDOV34gIM;X}*eb3bC_UV`+8dmf?R-}MmPaNX@R|K~+?=-~&65wWtgjBc5B
z7rpz=hXRM!qN?!RpZ_k=FFv0`RqQQDOV@53$i(W=8?O5`z52?V0yARda9=b9*y9T{
zZ=H5GyQ(msM&d=;n>`~4FjBz##tj|sAVP2#`wC~_8LZWz4~(D<|5{6p<&6Q7R(`UX
z5_q1x@a#U6%7ek?ckN!DoFnom_ozII=O@^T4>uY3UU+qjYpJ!qnTl^8M!CoIq>_7v
z3r?bLP#}?Op;>96X%LS^Ts06*yJH^ro=XPO>;L2F3N{j);j^Esc^yOoopx9r5BAA4
zYpywG|M!nJ(d4H}>EYMb$!m#ky}&fsz3`T@F<8$A%8k4}28PM47xt4Xvoo|o6$yAD
z4&$<9_K3{>soKd>&~(?9y}?6v^La3s?63&}g8oE_d~>m70F*5Qbnt{beZYA7*Tyet
zYg4_g9ErI#D=0f5ozBibl#0^}>0_RrK(O*~JWqMx#Zz<Go1nt?wHn@8`G-(ZdI5dB
zWuX+UX{@Abp5C~$;Aq+>qaUxMI8O326U_&Q{kjdHW4aHgjKmZRO$>hs)|#~(>$iQe
zrL`n@91pjn4n2te``SCQh9Ee!pHl6;8eYbm9|~?TXfHp(ACzWLz<Y%qA9zD+)D4Mr
zUVs9R1D@p7!bHR|mjq7(!iv&Wa$UBhRIYhFG>-uiO}xDX0aFUCjF-S?jH^&p$*ysp
z{9L)BOtJ<H?CXoB!gsrFtE(6HOm#I|uN;z-lW7P~zaXf3%2uwCbnMGp1HCWmN69%U
zRLf7G@Hix-#mg>?Zu?|Y0^j6^{B8uTeQ_0idFUrJ|C+hfhX<eBBQ<v@s4l+oXPR@=
zXSC|EWi)Vd38f844~e(<rui_2X|D(PhE&%=Z4E8d%x-f081MnjubE~U(;T4FL|w5E
zJq?`4ZQVUHkrtHI)8Tt($>Pag>>b#f+b<(EUKU^e^OH?9=H{Pi+Owr};j#I2=<qCI
z0EWa*E4Il($@~AchPr1Y(vUuBA@P3mLYcHX448WMcEN*DQOzsJ^>D|FWi;-#`7-Ts
z^~r_QuctZPqF|zN-MO+4u*hy2aGLB3Ldb3o7c$cwe2jG+gOAPGn+lV2sI-0)?ZeXx
z@D$`HWz)dao|MY&?>mal<pqzQ(0M=egXGc|=vRG?r@b@#irQ6mC-*pzKHWNBraw@L
z;0-#5{<iT`x?uhzbkp*`)1|$Srs3&*1n<7GH)Wpx&Ov8UeOn{dwrrQR6Ixrw(KG8l
zpi37$Nl)-1%xii5M1GRi&s4c~jox>!f_$2I{gw374?ojqpMIg;bUHvDt-?bmf1)_8
z0e+Y;JPBs2yE7?kGC~1aQ2{Ho`4miRel+6S>ou1&)<)#yb~i{uIn`UWr-Q=Yy(GVH
zzut1K(Fbt@*dv0e5Clw<Ae3+16qF_m7=)x`&F!hCI3!d5Qgb}kyftNOC0W271p!kt
zdtwO3y`9)Ck=l4SM#<g7Wyc0~XJnLgqd`-ODf<A;P~7~!=4q(@b_*}0Y@_a@G<T&{
zx0~M4JQX=d^azTFK3vW7;qxy3mcBgrV_I_Se2Py^r26G*PSm7orD^8IVqO{ur`=&J
zwD7?+xA6kn-~6(_?9Lcmm`2x}Qb_w1Wl9wv{h-Z>&t0~SpFrE`;GtT+wf;Ju+Cb=+
zpAr)9+oiQM;n8Ju+>P_-?!T3Z@v?#!?K;DI-)Y{DQF~bj6epBD-SuU!W7&BP02|47
z|7~>;*)^TRLtzbS5I06Wi$_8&wlra^nD%%&8xC0Hc;moR=$3(}@h*#QvR>hWf+NHO
z0qAe4mx~dytbPMEG3*HTBq*z-IIVzsrex836+ak+i_;1v4m|L%tbQZowb0%fY=Cga
z5~lOJRd3Ka^B-lS;X~?{m`3Xws|<V<!5RsKy)!j$mC6rxmBp69032o6JWW3BrfYfK
z-)ef{uP-}F!x@b&s65zPADk^E9g2b*|2shZ@eU{j31^4t6YCJGCNc(Qtc&Q!XD;0F
z+neZn-V#$(GLYV%@iEQ)ZXTU>)_9&i7)BE(UqO5AJwy<{{rU$wfY&>O3Ro10#gqBH
zv;ls>&x>i%f~B4`H*czx>5%N~EV}0U%Xu-3)=@*%Gw;U*vUcNugZHCuS(!AbXh0~G
zJ-)o`$rXf;3J1M=1l299mhGRIuE28UewPoR<-c1@`MlsRjy+AA-z}%iVcjU}fbO!}
zB7wK_4VqpeB(P4RZV}I=>v*M%*Hg!<U_68z-Ue8=u$JO@G3W5d_m!!Rs?RGZgK1{F
z(5z*eu@GGi{Ds>B9~EA`b1z!5X1i?v#G*-VKDu~xK0WxKwKVz{IkGo?7Vjh&&<h4b
z2JgP8rb1qzIrS`U$H$MQbyT+<uSIspLp_IZ`z~3#ostvd>HaI(E5RO#uNKybH)Frz
z4Ek^`Pl<A$xR%%5AS`BnIwM41_H7Q?*V%Li8BE#ZEV9?K?5VV0ab}pZvyv@_gr*~H
zc;FIappbk=##_9W0UtG(JU;YN-jT76p5omTNt}x*i&J_YK!02RDIJtmLdoo<m{Yw>
ztAee9@myBfRKv!CzBrKyEv;WCcqen&OB-f0-cZI%q_1_u0G^4}JjH><oKxB3fT@m!
zTxY+OJT_i>(YH(=@aN|rF7=f0`U=ILUU5_|sl1usrrV~l$GlahG<x^Z#+Ay7t<<P{
z)HUrXrQsSnfY(HJNpuF!peY^)Zf`Gc1ST|_8U#EXuppRPrx+5b<=H2mrztm2<Q*2d
zbi~o4WH85q#!cm$>EHi&gU&wxG}>ohZB83T#225<2{a@iutQ=jw8Y9-Or6x$)Ddv&
zx7B;n1TS;G_?8Yk@(@}4iRqP$%nTOYK^TB~fFV>_QAMT8S5i^&AR0D&2w_SE-V7%{
z3TJn{V!k+>#g;ZbSd`V)*vh*rN~!Oq18LOkW5gR#F>52$^87g#SPtT8he1;{qq3!@
ziPk>9l4^N?L0HXreHiZ$2Oi4$UN(@r@rr$fR^B(i;A(!l;iiRm1k)n}J!lF-?8{RF
zX!mfQ%&mkh%`Rv5Klk27y70K3G=rzM;Eni%w*X@rWMB4HOg*!&e1MO#hhAMnl{K0d
z(F+f-Fib`a%s`atxo=H<x>SCfnd$L#^~t?y;whQ|fd!l|f4qsep9XrV1li?l=gGd-
zMfSZdI@64yi%0i#$i70CJ%ME}WZAVrO_P1IA-ml3mArbw+EysS8i|>2f2g43E{UPS
z2)J$9GUVqbS=M`M6CYIc?Aj0L{K6yHU^q~`5m<b=szLKeCi4l3M|IzuUMc_FAdSkJ
zsD=K_(-Y^hS7UsS1H>CKlRXw?4ZJm+!zrA1NOrNrtD5WRH!J?bXxfy>MBX-<z*{~M
zHnV~9{Q8e+1=ol9`v9f|%Kn8l5`Gt37WOVQ&XAaT<Fy8%mtOdnJS-a-hO(eE?=c7P
zn0SyWji}EN=-e<1pdWM_w4-fxOdl8KzPR5$!6jrePe1oCU31wq9|Y|nc$&}3>c$2{
zh3te-rSbeUifIE3*ro-iN&~MYLyKtI&68yN=!3t1g0QBdeB)*tU@)5Cp|P>iS6x=3
zd3m|CjSZEChCsKe6>fKpN80Ye^pV;(jT*2c!_w=pP*ZkWaGu(&;iTb)2bk3U>2knT
z;|6;hDVn%hdeL;&5ld?tc#41T6C?P&2h(34KDl&#Ws}VqPv*Vy@J667tf|1UyOvI&
z6LZ5uQQsaZ@(zLWE#~?F<l|;pn9HwGZlkbvYXBD^I<njE$Zj%pO!j0s+$&t!4P!#y
zvB7VJ#HoaG)UhV}lYf1PuD$XmC{fGcZ@VOVwo9hU!U09?yya7cp1k{_k_UY;G!&33
zl;P7zXb~MIkJmSB;WZFW4tmOARIQe6of;Yz6L#laAm~h$*sZ|<gR?I~g6n+bPxtaW
zC4Mb<ZeN;Af&J5jRdpdJKu{CR76U!N@~#KwKZ!kTN&Lo6GX$&8gz^&urDmRb#(OvL
zBXpyT`r+k+i$O{7+dtk#ciebaKoz*JHnB$r)0&u$NeqC9Vg|eh_&7rw3$s4Lvl+1N
z!D&Q*elVKY_Zvy5tPGrgi-gXuiWBKmX)t*k*d>jiI;tf2u%JdgU(zmL3eQ>8u)5xv
zC21UH<%Q#l5X&?)&>8K%jtvE8z}XUIE<1dzaBg@g$0?X@0mg_IjvKr)FSP8op6f(+
zO}p{aG1&ukiHbwXj={smy~8D;)<{@|2*9xx`iNKPgSvpa5Oc{AP#6Qs2(a=DZ-ZS3
zjfpmvMKd5k(HXpIG2y~pBVl4j9y5n)7$I)!BOtk(JYKmbFIJtYT-b+kY~y)qgLQ~q
zj51}x{J@|H7PP4i4XjfQiC|2GQwGn)m;d{Q50+XJ4q6PhgBpl<TEnH@;9b%MA(pk%
zG!S|)-D#|Ka>a2xrSk#Tv77c*V+7$-4q-$%3<+s>cq<%QHqcalK!$a2vSSB;24q-q
zxdNARRjqOLfI-bDvIY&*&XZAY$@V*~Vc>Q!VyRjv$sq5{loDqqdlOhFyz@e9LP%&z
zjlo?$+=_VpxWdL&4g5mZ<tvVvfJYAx<!#hzz_-IwXrU#jOwgpw(=smfx?C34D7?gn
zQqBJOi!R68?#vLTHX;quaT!@%Bc&6=+wmHJdw=%}swW1!Vrt`|-A{CzM37$va{xjP
zrZ!|yvS%w``_%=;B};Gu@{J5FV&y0h!2k|fzd5woLH(pKwXq|D>V4L_@ZgWBjQ~9`
z5GEmDG_>$3l6dRpcAlcIZ*0)s!r9bBO`O-n2PmpfBj+_RjKJ}fJgz7MeyAY4F(2_f
zy^_F-R#m_|HrnJk2EMY#LhW=E!vxIpzX`3dV%L}kBG7=_k01gvF_f4FI-mi!UWkFn
zEx!ZR>_VvCl6wr$N;Zeu97zqzHB%9=U)@0!cenx~+CkBGuRWaFLUE{Sa?<q5x58mS
zh9|(<Pcc|40|J9Lrf%SZ5G~nMWlLDd0-hH!Gi~5wngYfO@3FAeV<1=<l_>KQ->$9K
zKw5iG2iM;UPlsfPM+EpNj~NosL@Y$C0Zadjm_`gSrh&*bAh$S14b}^Tl|@$TZh;kK
z{P9+&A6@E%G4S!g<rx6R#p*d+vEzoJgL;zcS_P&AW-K^|Fd{I>W8{ad82DRxdI4Sp
z7!#7|Ng`M+OwBMp+Ig~q1Mgx{I=7Pyq@$)n;&3Fk@<i~9zho_KJYSi-Ml1Fjal0;K
zsgN27>~0}ZVgNA>bU*{4dR(aT4phBcqhgR@0fVV8R5|qHgh5(}a>QXwI6(nvz-kHm
zw*|oxHDLlWg9&4zMHT~XROm1G=7a$g;EmvasH>HC(KPWiLTCfR4<Bw^1d+iFoU4JM
z)6ND6cCN@KA2uS)zy<}|Ix&xgsgYRBLjxZD%L6)=9n(M<8jyRE-os)YEeyr^168+t
zyJ|TXqZR@#_Cm>a`@-|G`_rrgT2(69_6qDN2EdcJ;)Rn&xfmgKx<;8b+nNbEkoFs_
zxPEbb!1+|CP=ffH3fifecO>EymJB}lv4cQp{)h)ei)!r;4+C1*y*p@pVyc6uS+Ipv
ze<iud%6KtDf>jd>rUslp0%zKUjKyLa@T&p67vV0Yg6df6s`6vkPSyY`+}aMPEnxJp
zGzyogF~^fJ8@>hCmA17yz^advDbL!16gcYEAvN}FOa`IR(W3C`k#!3^5W|3w1(D&Z
z!6~wDd>v8Yg9ms**yWJKueV6BoF!t_2o8h9ln0CnyqH`9(})=oRxRzJan+ahQ1N48
zM@<7RJ;{1sbt#To)iFZagJmc^NE@J093zgAG$IBi9%I5ZCalH+s`5j?s4md1F^hth
zX<!f#1Dvz7Inx%RQH%QY*x2f84}U5nm?*)@jC#?=_}GErk7&WxPhJlJV<IuZ-8_)R
zp?nCHP{6zfhlJehUUx|>$k)kyWUlpt>ZkHalejMBH+Z5<rSaxW6_1s5eZAlftT+}J
zZH9m=()b{#xJoNHC!T6|;Ka&IeeNoH@!#$%xKE7beln3;I!@k{tK!QRb6+|gvb&TS
z{jBSifnU|n(SKE3>+^AjJZ8V%F)}RI@2z;<0HzesmsA|Q;J&NU&NA@sTDFwikB`Eh
za?>?J6EI3%k)6xNoibWJXy3^<Tq*6mYzgp2)AiG@lqb@Xp@WV1GNuWf>!+cN2qzIw
znGPNCy<ll6mz_wHk><jZp~Xgg`O=kKb^_yF#WgYBkRpzQFQVm)cM_LfH+6zuHkji~
zA7#r{(%A9G)3uyNz^lBkox*W06uj|c81`zdY=~J_s^d+Xa)ro%>)3I}%Ll+Jjw|#%
ziQfl>t5M&S2_i!=^Lg!*t0caB*$U=m45u|d!ONt{mrLEK4@YmSbaBZbBd*Hu4k(1;
zk|LVKG%-jknktR@RDAhzu5a8JrUTe`(b=TQ6J(vm$`z~^E}MA$Rg#825r@~K6nyG<
zP*gGNWfJOUooT!r&orUmIDQY-1R6c|I6CfxV}!SlXMGAVThJC_>gSPgNv9r>ZL2w!
z=n@)mc8Fk1Md!HSU^T?bx}pXG+nsw29zWbdI33Cjzl-JJ9EpjSP2Xu;b-Fs?vWABM
zA4hnSWuJ8U4ZN@)PojaGz(@!k@Lb!<<h64PY$y%_IJr_zujHp%ZBKzb<4P5RC*{~{
zXrp45Tba>8tVdb%UI<17z7{l)Kw2Ol>WFOo0F+FMp7n|W7<I|jg<mVI83#@6-7;pL
zOH5~3s{`LG883i@I#CoC53hi=J*{!GxzXg<2@0%s!g>dtFtQB!bX;7x_>n)|Pq$6K
zlj{q7nHWH@y994?cK2O?ZY=Eb8nAYgU0#@&0G+P^xrgYzrro3Wcw~1zbGvp8T}EyC
zI1!09F%UUy0S_{!w5ZNV1rX3na54DOFl=}pwb-%^1RF6Mh=mg~-(b$na*JtT7=R5%
z-M~1{CqbbUik2b=qXEW4f^l$F94~f^<MXcF`LXjL28W)NkO1Qa1^~{fu*2B|vJ~M!
zE4+Cd>n1GO0xq5jHfmyqgiU+9e!|(%yS_v*38Jn6xqn5_QzAf#I`3VO;BKdufC1lB
zdXOR$C}6m;6zNgzxmx8rHHZ%C%u}$zub}HaJiE|!$#Sc~>B@J52|v%9Q=!Ew!1P6e
z7!bN=MK>U@4kQG&2RoW4Bc8W#THe>@0jp)>mGEtRVrB}A2|iOowG6JZHIzL+F+(D#
z3U`e{)v&t;w=phvoCfrs5!oFl(tG)i6K@CAw0r%&xHG^S@C?DqJdrE~&=%_8i>3P+
zI<#3LDwnUST9qXf?Q|@aSjk(ngT^f^1%-1fREC7XryEe%c}nO&M0xK8PwikzL4~+D
zyim)_3!$L=UA1Wu_%mz@_e93l&_?!5Bs0s2e1x{bk}DI784{kV>$(N15xXvjG0t|5
z1}r_p`yS=Zng!jsQ+Pw~7A01Zl|XKJs;o<2oo((WNKhj}lMZCuP?hX9TR>&nt~$1b
zkR_@aG8oCM0ZAwS)^a~_13wzX0xQJRH>LyByC&=qsN7({UgVW>wuPt!QyBd6ELk4{
z|B4o(X+(e`=%NV}3rOQ&EF8s+cXYW0$lcu1EJca%Oz6zv8Z#u^G}cA)^mgl_+{M`1
zDH<?-^kMdnFu`|<Y*DIow-(iCe-~w;EE3@{x<rC!V*vz$G3Ts6hqv-<joWBz3HM?r
zT^B@WRxma#u<=+-$zB0>LqY+%bEQhntD{n88;e85h%ny3s_6vlA>f#Zi{s&%v)ZvZ
zRXz?HCh^cQnId6)wN8TRa<%dnPhLAI(;jZrVQ7dk!SIRT6D)Fw84{Wvy5zUsMqQG(
z7*jh~18%=+VIkH_oGr0iXvDL<oziwjI*OHpl-?kgsLr&tr4Yx*TDLW>qjd11IrFXc
z`Xea3^Amdl54_sW2NN$6YPLm^JQ`!_1aI8b-npSDVnL-oz{e-Cda%=iFKk4#wKcIZ
z;bX^#$!0(d>m*<_SOfUrnG1f|7ngawFcfxX3m>2rm&iQxc@p3@w*Awp#V!z6U8oDN
z5@TU!Xu$WqGt8b6Ciu<}J)AmsNpXC)Z8(|;0UL>;usYxJ8fmv0Fu-{Q43aX)@qlLp
z3p}FQ)=xZPBL#RKwFF*Q66edGJcV134T5IGS<23NF2u=;c#JpK7$^*L!a(Kl)k(xs
zgeV61<RrXrqK)vXZfjE-sKT>zTcv}LB%vYZ5%MxJrZKcdj1FFTFvoO5JhtPCo-DK&
zx3#6-#)qZUUzCla<`$NTq2cvNOu!lpQ!=o3|D*TO)N5}x=s{NO;DA>KpQJ?W<`7LA
zFtNx^(f}GqeRdKHuGQk8npoHY8o+N?eS%h}dI_!}f)&&UxRqL0X?Ldx*0h!1XvQO!
zUA14ZYcv_{1X_mdc;pNbe1L?YVDFTHgF6OWJs1&{5&bI;p$Zw8WjVjWx&YFO<cCi~
zYzF2yybuX&D7eXwx?GJ2Rj1RqQ2BnZY&6I=QV)1#gJDWX1&D}~FLCN+G8+*%QX752
zgiw%CzV;u`m&S}emiqSZ6J^T&$>rpBr>CELn11)b?f#KE84~?TeLA_Sh{+o_mM|zJ
zW+zc{uaqz_Owg3xsqDQoeraYwh*)w#s;0~ka9yStzeejPfHBoGoYw$AGb1Rds>}or
z78`%s3Bih8%d*lFD4*NjE97@i3V5heEEnc#Pc<s7uAt?Hr|KwRJlt&ELa;J7c$GKK
zOLnC~mup_PMB!7>a9(q{-0PkntjtMAr9<gj!O0EANQ91f${qwYJ29Pd5;I&Nw07y1
zkgg4q(3>7qv|B=&WdL=wqW~#Lg-MhdpGw`i&fr0#6^N~{0!wfLWw4;w(WW5GVKXl;
z*U|?A>Dp*oL_{=!rz>zagqCe7<TCUZ*|Fi(arg!je65D9X3s>t#RK651aArWR6(|b
zvM~|Izr930N*kfm*GL>R>K8Qn#AE2a86VQx)$0^5JM^k;-C<#Mp{<o)a>a$zkBywi
zA9|K*s%xx8of5Zqmrki-rw~obNv8e(a|k7NPnP<ds~Tz5W6NptjE#~`8<0)|r<G97
zp?OrdsD|cU@}0qF!MS~@|J8#iF^h3|$#CiYi>dsz^+q`&Jx=IFLw-Mks%CGZ#nXS5
zviwsEX%N#)$YfVra~o}ZeI2d*<5DRLR-XXu$gdFh7dtCq^pF71U=;-b+pCQ*)jczj
z{&r&tWo2l$k}Y*D^z_>s=!5UK3dL~;=g>rMr_9s@YUV?5-kDQHkH4X{?dgZ-(Pd+M
zQMa@NSt<S)x8GY|RSDin5#j}-8J38_RB0jf!2=^GNjH9Lwzbf++}~$@y+t5~^hu>h
zt}UYU<am+q!GEu%cfSc;)-OMqb=I2>9@dSPtgWYskCqBO==#N*?7DvDEmPO;{$X!Q
z<+@Z@ThT}t->3Z^RGzOZ9x?Ip9K<v#{~CE6r6y><_wvSSdVbw(`l@=F6!uT;LHCxN
zPu-I;cpkou?pygf&8gOS>BnV%D7lET^|A+6zfE6nT`qX}$ysz>!I5-q&Ip=YyMpdr
z^`;E8nF*=%VDUxND<xat);DgU7dFhMZ);YFP5!sx*HE{_G>tL-Ub1Z+-BS8bBW;af
z%VYSz2CYM2EJ@-;1fvc=m`>uOvC}is<q7@OfBl!f`rp^Wiz{twCew(Q^$_ZSCrcqm
zQHQp;(rimB|7e?zu8&ak+}25`GIa$En?0g6%>#jVa<qz}qh5jT!Kos#dtA3}*-F2?
z;{kf`_m2k%RKjPD_vu?msi~1YMF$Xc$v`(zAD7}Tn>FLj_kHt*bwFFcuA(2$n?v7?
z{hS)sY^S1IhZ-J+kuM!c=|vgTQrB$c32|1;ps6La<$sm*&9Sqo;-hjZx_KBSWSACk
z0zd5*-#JW-41*!y-7th|f3BuEhkrt=pIJeL=k+7;PB4&XeFlL}ir_cr{J2)7dW7@p
z3T$Rt!Hry1p^;&UC<IGZi0F(rKL`O~7V}yw`etbzUH0HII{ThQw2lX_X=nA(=1sZk
zYfmerg{$i6#9QXm3-6cH8EiZ#F9QsWuNKzODYq}A+4Hv2<TLwFMk-duM~>%3)8yC^
zQ);tZXF_(QeTFC4C_3w|MRdk*7SY1h+iCI{z1dX_ofF-A#Xzdq+C*pHy@*z9XrLR|
zV1|65%AVoh!{EYH+Sbs@E8{g<z=5v6g|7d|x@MZt_0+Tb@D1IBdG)gjx|EG+e5OCW
zQtI;iC9)g9p_TA>*$4E?c~8+rKR-!7*R7%J`kyFk2{26GJm^$f+fYRp{q!jPRJV$5
z8FVJ4V!<GXn+KgiYuOOEWd1WWkMVBme~NC9#L<I8E~Vo10;+1Rr38yh9YgNdwWV~;
zlIQ5sh0oBMhDy4wuU4O8`Q;7&qiYubRX+EXy{WQ&UEiPiad0?R2PRt}8xDv%?acAC
zaKU1_?Z&%k-jDO??DJ07#}Mc(xbD!uWe14VsJ9(oB%dt^b^vgj@)t5(0@jnXwRLQv
zr9n2t^akK?#FxgK=9z#F+OS50jR{TCPC7^8oC{8;V~#&UUQ4=Ro%Tek7#}u#2wi&R
zg_ND0#pTWPzu9x>-~V`n1`O;cFOpfiW<B-jkw;nC-Dt(~RrJ_{&&UeVq5Q&{%dWau
z@*5i(>CM+?(kCB&E@b!Je*~R=_Q{mrtB0i5u;=5xdmfSa&9_gXg5LQO->|Nn9=P{0
zi64K$(R4DuU???}-QpZ>yK6dId2P%KEX!{suOnaXU7#ZrcRX%5hD1|E6D|Gq0)xr5
z&zI3&kM2tuL%UHO4;J$${6O0l*V4!r540H)-4D&BxTJV71X^lasO<4l>M^E(@{Z4^
zP5iWlP;~oV?8T_1)V`)mGd_iXaOsIu%};o3jcru**=8DWT`{E(PN$}g4W9KG40bdU
z{9fUp9);duknmHn0qo$zU(#>8qn4_g7P|N4H3s3AKiW)xxO^a$@Y8r%c_XE#B+%UD
zb=1_-PG2mjp)1D~(7=Ke`QS<Zc{VQUc))!2osD$tzTN4lk=gXgkJS<3Ro3uPzE+xV
z>ooVtHar0aqaKkN|MhP?gT&jq2L<s@neS11b(1L`Y?JGel|*;{cLP<kr=nL5yRlhe
z$N!=`ea(H@tL&{Wt7z(<N@?l326}2rk<E~(WL^L6?-pHu$hu}@1-f3shC4zP|At^-
zw0Nwz7a)%>Tf2)#!UIsx{@>Om62l<#&DK&Hoi{?JIpA{dpVpJ^So#XpwKPz_lsq1M
z<LRKRVp_n4!vHS(&GP?9S>Kc#DLXK05PiO7A^m#!KiEj9pxXzZ!_UB)(S=HCTDH^k
z>pw+Q!dn${>5%MV>YJQPs~amNubLMhRy5V}n?7*rBd-+n4EPP%e<SbB{Kyj;1@f!Y
zzwqKQc(>tY-(J6+-hN{y?e~k3G;;ra=$kn|1k$lr#Wmv(K`-EoOqpN@1na52t&z)2
z*#%U6u@TYU-pn6A_W^|z{EF#~pvPsi^xAo$+9{i8?^a$L(ZZjEHeM*o9ovK3;1vfe
z?Ut2E$Bj8k+#c8>GH`Hz1H4<eOuBB`1Ti93mX@(q)lSEbK2qS5Q<7y+$J^6VbngJ(
zQ1*+1_7(Th^*3BCMnv`28Yw^b!ZQfQ1;WLboi9ej*I#{4Km9PDa&o#Gb#C0aiK;5M
z3hmsy93vmo808x`i(3krRh3neuC1vxV8V@{Tc}UCxLpxGk~I=aj@)B=$je-|E!Ff1
zBf>2-SLp|w@J$y1Yb+2__=yam+rHUsRP>~!x0^-^^4l8PsFJ-GeXkrugQgFm;g9V{
zO`95MtA1nmst>pk1^jNUA6Fu(^_^E&;1HQy8Rjq5$Ee&5EgJQibgk{~q-;%_7-sCK
zeX{r_!_!miw^Kt?8+#h6>Ho&$i)Z3K9`rU>H`BLE>S!wucnDcMt$~ouUMGYC9&ml(
z@l**^lC9$x@EVM*JkTO!sWJ;qDe&=yx0i++#vPJFzrLs+O*^|cEm~7g8>*V9Z%@s`
zi2?rVQwnK28@rg=>64cdv<!8_i0~7vx>oQL#uw16`}d)@emk6}Mlw~ludB7)H3W3{
z;Nj5h61uGS(KLC$So*fQlq#F+sHZ;tu)1M0on0`B>RKD9p|y$fle6Umits3$+3O(M
z#)GDmC1!DMoaEbUwWky}zvwoQn)s=F9eXxZnAq<G`p?KI^ygt$(D01DD%;o9&tgk(
zg3q>X+k|EYPir8gXKL5nT#PRce({5G2FcS4_yUho0#1v>d<Gi`?L0uc2F`C|Jz{zx
znn9bo07W-uArU+hY?z^#tq3d*l~;^2ugyHhBShVh*n6M7gz)@%i|B^yZl{eK$|a4j
zBaR*=2F8Z<JdgPH2lVMjpG(<cM;>CpU`6N+*ZrDaedSHb8!>V?9eVgdf(PT{mT7m<
zyYGA`Wuti!Cl-RFrKL*wwz_Tf-&fxe7)9{Kzx;!qeDwdRq;dWB>mS5xv876z%YEjF
z=Oqok!wI5WMsRO}a42;>*uWc$KOVCV$e~`R^`TXdE~j>W5)BqG;J4N{Q}OM?DEFA2
zRC3R70f#|>g_lEl4tm4C)>0Ec-8w_%Cz~mO2aN)D@22!lqs{Nyy<blFu+r+Tp{}mT
z*4FQ658#TF(I8j13Z3<-v>R-Ad5RLQSZt}%;ZWI+r>;&qI9Jw4s3+pjdFm-OIe|_+
zERT(ZWSTWsyYXYNtY<?5?*1c2WYH}b_LHjAT8jX@?-`F(v~;bGcOK)h(PG6jXu6d7
zl_Qb`hokn&qQh8*WcIAhX0HT7_e{+&%Hf5UXB^Rk?tGz)Z@O)i%~N*4%KY*vx<16B
zYi_W=f3%4vKed7$d2JngB--iL3pAbjrD>NP9Y1u~FM9wTlRKO;5>x1_t=jsCZV8$Z
zmBou9FDyKY{<!ijs&8%NH4N#LnW#S?@S2D7dmTy-m(8SlJ`(|D>N!2IR-G69Qk2$<
z&dNWSo?16cybpkXdE*y!<Fc3Oq1EqD6F;?M+9OzSN*8LerO?um*00@2O^r=--i2q;
z$o)ppg%_VI#mcZS>cx-95p2IJPRIdNJchv|fxxQ|#4|3&gz`FwanZyEdIOh5*NBix
z`F^8UFG=?=2(N$mf|D)bmBDxo??luMi6Od|VC9N3;iqin8iTL=0&R++uy+B!U;Rpc
zSNri&mX+1bfT^lvS2aJ;DEt8f`%;gdc~ZWjbd_9}Eh&|2UXL7^r}=o+XOhOE&b$9`
zoAI7{$&B)s>Imu@W%9c`xwJv)wD(i{QRT<wwBes-+XoYD$xZWNh|{nK_Mui@tk>4i
zLe1=+?afbl$vG)h$4|AnNB5wFw0KJ49U9%(RgE<iLw+}c*1oukzB=?1T5!!=>T}6J
z$~{t>-U?QqXPM=<;t3-K9cg__C7y<ZqVK#0=PFdGlbSUh3O7{w0N$zd;8la@Gj6Nb
zKG$5$SPyXfMg8d&Huz4sc|J{lb_HE{Y(5=2T>HJ>#e*x_{q9Q!P(6E?;EAYUk3|Mg
zTN!xVH>UIYmkW>cz~d)<!Q*KS1RG69StuDIEr*dX{?-Nb3@<W;_W_F~x7KMl{Ch7S
zKp(R41kVK4J5+CL4O-@h2hlYzPBwInhU9>0rFkp1$%54f*!b?w3t+L}Gu$BL)F2iD
z`RUak(*MnWnjSBEkFIC01QtuyveAHW+u$?lt<B#OJQFGL$yCcz518sexMk33^fpgV
ztY*(dN?ekZ>5sfpZhSfT=*3=*-xr-n?^gauv$vQJeeYMzqtfl=^u^Yt^wio}RKQav
zSnwImfG2YqOPT0D|MqW=w$mk-Uqp?Kjnu?vOH|8Zef+*d1=cYC!-$acBh)C)vciA>
zg|>Eh9vavKp?})6=?p*AL)Gq9u6ZSbQ|FZtf~rB`;3^ms3B2@x*Yda#?MU95vbEwt
zDA0|D{9Zi`a_Z@S&FZ!E*6Z&X`Dh3gvb)2@#V*dmUUDtxsfp^Xnw4MJTg&U)ueX%d
zRBP_?*Z%buee}U>I{c_nvek6>h+#6NvTDU@f%EePg@g+F?==+IZc}cXGxZ@=a(;@e
zfvB5bLrZwz@Ef-BN`8D0uyypn8Ank4@@<sKPn>PM8>9Gc%}Wu_^X(ZWi8OFZF|B*C
zOyDct-z3-SZ@0))O7^H+UN2E0c|pH||7I+x9cgu!N&?6QWLWBsJlYYe_C<H0dFaXB
zqo*bp)1uY&bk|GfZ*E`qP#}EtgXZ;{yKI|GdmO~;X1<(XD^ncbE?F)x*gE<zUQoM|
z7bO~ab6xNjc;kT(rcK;vN+mwN!j;`h^8N3&iXj0H1qOM9RQ6Il{GauNEt~LIU?;`e
z&D#CWt;|Z#E#8x-aGv7+@6@#uwr;y-$n?!m^*vPr*=_v>-Pe}kti?=!U86nRjmYdr
zKh~_00(c)@S~r{0*+T)31$K69YSQ$AvVUy&lFO2{vL=1U90pa#&qlF<t)}-ET|ht7
zuA=|9?h~_eN334f7!dX3>5?^#+I__VB1uITiI9se83s0uhSN^VmzMHpIZs!$^3+BK
z-FeR~1W&sFh0qy9R7Qkdzide89tW&}P;p_llfUF3DhL-W;K4_S0e_g1N#bdaX7-{)
z-H@2~;{w9^g#!-WkFZ{1P|*N`wYlH@L?@j*ns-U`=It{F(&kMSwD&&4Xyf`#^!e<s
z1P-TW-FDYBUh|-NFBbf~m=-NqN~fJQo?swMoO}iCwf7K##q<Qi-G8{17rD%(icOV-
z>5UX#Z_&<Pjh^{EXv|5+%G3wo(lgTN!b{Gf`fc?*1u_F!RLAgnJ#y*FiI>o_r7P&m
z&%Y+C0TQB52#wemuPEoOY5V=-V42ET`N%TL7^2P3V)sUCeJdsLp8sT?A5OqFLGFMV
zC7FZ;n$269D2G?_*Db82IDQfx{`kH!)lv0%g%|{@pIl+6_rQ0LV7O}8{t2T3d+Pe~
z6JP1?7E{l0g*+7!PZjTKQ)vP96`S=L1Op<`0Ng+$ziMrdU!;2S2&gxD8PSr!FGuh?
z{AF4(dj{L-skb&#QK7a4Z+&GWeZOQInuvbMYg``s&pI0Y3oNXQqgg!QA{-*y8@Kbp
zHgR;{l>=p}<16k5$%)!_$zP6k;OSdRz3_t3lnSH#g{S@fxF3JWe5G>Vz4mnN0cSDq
z-YDPFOcm@U!6H-awz&G_0@20CY*cMy?~7L%Sj^$yQchN)cxG_39?a*fU{NckM!a+l
z0|N#a7JL@wCDRn%IRoAQR9Y9A)EG5`gnp@cG$f;d7g?_09Ty37LBU}Hy=wbrs%qIr
ztG8EBBR@sQ@y?603l3!ivW>p0UC!$vnyHLont8y)RK}S+MS-&KYgaOU9A)y^5?O3q
z!1%y1O}*K(P{SS$EMC38_yV4`XrX_Ue<}H>5Q{6jC#6$KS^@n~w~~4!cB4xRjux8B
z8_a2SVJ_4cL=N%;vZ@50_jPO6i$~#N-7B$h{$jm`AcXiH;BG`PDpwHAMU<h$wU;x`
z!DMF(0t+r78G>Aa!Z<J{qHai3R#Z{x@|9FnJczJE15*`P<cLPVITBd=aOSzE&;bYS
zr*XvJ^L|)h#J6v65JLmXuC3vx3pN%o@MCAk+2@}|`|PVdog)8>&*lgoc6gkupTdYa
z8#HLysx>rX<X&{-(T5teVWc39MWD)%z;(i;OT_~MFUTfdfLRuXC&M7V8%D53!mn2X
zTRYVm5+h$Y$k4{p+vZcn2j$d%QZcWa&~CIS-1nb{Q286{sPx{&)c3N1yr{Cf;I!7a
z(1NSkKvX@}pu`c&FS)I;m3MlSQlCo)(jl{t5pP7rtc|iA6u1HPy`tC0Mu!%H{A#Rq
zhK##0YC)1}qE(kkH~JJ!+L$Z%+wOySs!6SDc<TBhgUE0HzJ@SpKKI^6o|foI@7%k$
zcq2afaVsq>s~5Omj_FAw25Mf5dT!5YJim`7Ze%Z1BzPd|Mbls`L_}owxpO0vy$n~K
zTu9gObOu5#djbCO@n-sY<u*zG=7rVt=%m3k<M(?@8fzC|L?8q!yJCDV8pmr*RQT)k
z5;=e4{qMH8>za4XV8_Z--ad;D0v5bJ^y*s9*A~MmTEVW6eWq>8H~O}FPfO#ioY(T=
z#)JWEC2`o?SVPaP`;=B}*F1y|t(r;q4>_M++y4eBe_+LbX*(Mcp!OiInfT+-i|Jqc
zUMFP_t(rj%Y;+);o_`RX(`%H(@%7YRSI~dT=g^mYK7~3%;;|wBXO#bT#T!)JT2Ipl
zj5qSI2=k%UGi0ZS2m1!BieQbzdow;#Nsp^O(DUed^zlbgf8J?`fL(-7J^ueRBY*|O
zaI5Wd2-KaN5y6I60ADa7c*RH84wiczN44I;<{*pNY46&=iC^2;0BC4v2+$3b*)u;+
ztW_8u7}!gO7SXhuCy4>@;P0PcFF}s%qOc;zvuTeh6W}!RVi#-3;_aka>;YNN?xi;8
zn@FsH9`V2?_W<03vY+D9Kqp={ZHGvl+CN<mm1<<ycDNz6ZyGhM-LCa)PvmH{u;qv3
zSq~TBmleejU235jd-A!5XwqfVO+cSwn+Soi-aV3OLnU4`WH0O6Gnt>X+vN$~UZSNU
z!3#yxtsa&4<nt{1uPm~w0*@;^1~^3%?<K%)4QD`C=*K%a;Gt0qP!&wDG6iG1hUf_J
z?7$lV9j|3?AJ&@r4Iup|Zue`g?T)hy@bL(E|3ogIYKdB^T3kFIT+kyqjVc;y_$5%9
z0i}t+EB|@T1Pp_UraEK6q*e_EYhG~3^YH@99u2(p(zX!OMGr}QkWFq9yrAt=!Dmpw
zgCW5MRx7}_N%fH@@1?1eejPZ#o514APvQ4%$RSLe4^MV0k2RRG$L@tDKF&a68mC^c
zf#q@^z&6<AWL`+l{l*rU-!`6-iQ4%POx#d`r7BC*UcD`4ChmLqKHj`=i)27s?WFZD
zWIzu}7g6^}C>APtJEd2E`({(Q_dGTX3vA7F1{etI9p_Rg7;NW^<YY=O#VWdc^40HC
zX*6`y!1L>22mM}w>65?^jh59b2qbRF(d&sqbx|N;;VZ%@i!AE|{D>Y#73+Cma|>%X
zyXPy|Nbo|@RJ7f$;jWRuVC}^t=;LO-dXu>Z%vxu#GAo=mIN5Ss6PQN9*&X2q)$amj
zM<>8XLD(r{u&&_ko(L{uCcmMY4MbiSq0ta9;|tH<<!W7ok*h~QjH~sm*`)weCFQ*S
z!ktrR1xVW={j8A?o=~?Q@IZ?IcI6mpUMLBVxSPBJD8NR{5rM#(vE?X;D2cv>j|$+?
zF0m@nuByy}Vh7Muc-tq8C!ueF=rlvZQirc78s$qq2x>J?NpyBlO6%-;c6ItY(va|_
zt5CgMh(y}Dp@_TCb;<H22Lp8g)o&I4;9SHG_fRH(73~^OT~78L*ir1$8r)uLw1|)g
zJi%&Dv1TVjEI2uoV!A|k^MeO0@(Y2*038aUr!_S5KwHBQD1lmdh;<=a2$N^)sNW$;
z%<8Qq-3&dqY9JXncMZDOICWDDCaFNn)F!xGv36`G)>6Fm+$%Ku<1ad`Vu-BkqSNZw
zod{!UW2Xi5X6Gk>8P%fJYXDG)3{{B}%u3VIYgCaFB}iJKsA~|=&MQ))TCXm(!M(qy
zhAt!fPUt9@+6WBjEFB3DB)p)BZpX86VJ`}gxCb<*HbMp-IIV-T6&@_fc1Rp56+wW9
z27et5N_RFsnJf%CzacoJwp&9x_d;6<0=iwsBjH!baN&Y0C0uGT_)gP+uisEdTQgK8
zLFfl5^3q8JC|;!e=Z6x}KcyJt&eFgR>NugR@z<GxKJ7{&*MyNRbcMRc0f>(_xb6Ul
zgzuIPx~qa&PD<iKnwr!R*3h4Cp*0=(=0pP&>Xru3qCCL!E-E7+6aRd*85jTv$k4Dr
z*Fr(dRNqVo>lNEAYY}%_LqZg+1dm<2o(4R7sbV!6Ef}&At}H}7A&M2ZxP}30MT<P{
zN4&_X$1r!a26lJ{>U;sUsf}>!VMXADU0!Pj(C>GGu28M|xK$5Xv6vF;2wE`6hQlXY
zO8^fih<(6cShy)30%UN|7TF?hp~(7-=f$`Z*m%J42r!DUzeEGGz-mxIzfm8y+p9L(
ztqciWO+gh9E8IyM@YPQ{(t>^}@JZhXm=BQXDcX-{(W@;+X-8{dhju2PW3b{0Ppm5L
z(2G89IdYvz46ks3hu4X*>p@}Y!=00GRMM!!Lp)ddfESf`BH=aTI6Asn-#Ov{WCG#V
z>10F(aaMjjze2#a$`w@!gZfpk8vGiyN*;^=v<m0Kpx_0f?d_b>00AsPM_0+rY)X;<
z06+jqL_t)*D+7qPh)Z^PLn5TGf#Sz<cBBTR69=m>k`@d}RIe}$+Ce~r6a^D3@-n~T
zMP5S;GYT3|{UYM#QUs#Fi(e8Us|)~uboc}m_^T3VE(-EPQ8OmYT@Ze7{4v!5C=9lq
zmV_oK270WQz)lh^$E?qpHcLXsV7P%crWFhW!f&%!D^@t1C*BNRJZTyf%!k9Euydx6
z?LA_bHY7}u?4rg}J6QwPPV34_BrO+;Xe2b5IR}~}>B@blWrh;5(<+V;_NxKuAC68U
zNk`i`l6LYAe0yQ%rNXUN$tB~80~v#wpCH}{00&iw8zsiEO>cle=t={i0y0!xo&^fP
z^$IL}f(3Ai=?!d;#mm#|d@Bl}Wl?nqBn${lVc`4;=ra_$rCi#|l2&xBG_>gvyuuvk
zSuli$F(I@J0%l~FG$h<~Vu}=t?NAMb`c+wbYebBBRnWm+;6QgIBjPkHBrmbTA`%1M
zQ5p!he<=8XW>y8Az<7s9dm=*ud^`bsNW!=gplcopAO>i$<1Be`9ZFO#_ZVYs6meJ=
zyb^fjH;>I`2!ih>si=)<VH!hTGwwr=u)i?iTls`1BWTbnk|_^1fplZS4a1#ILT+}i
zyWGI7c{qOB`T?n_d<rG5OZiQlC{t;iL9XJRQHD2v;^=17fuQO`JXY3my+E(fuX=^J
zimSBJ`?AH{4yWt&aYr!Pf#b^-ui&z=+(r|nM{8wT+{E)LJ3+?-%_6Oxg(m8YlqUGJ
z*M}!1^cVEqDO`p$_*8M#msC0`WxCFUCjYPvnjBYp*;!?%7ww4;f{Npcn~>sbXY<(^
zI`bnt?#z&V9P48;`V#k-67DZ5ZYyJ0RR-PJbQYz4wp_mtO1tPZ4PLlx9QSLLR=j{`
z^lNJwV35WKLB(+e@7LdSjr@j}EnP|DP8m&;Z@5zOONI`n>!)jRyrT$ZDs3;*@TS}V
zI{cd+%D=H2@LME)>D5Yp_tNon{j@8k?vf!)Q;$m->YH{ogR(wR-&E9R;$4R{V**db
zmoH<Q<BvDq0A0*w*YcaDr9Lhji!wcZ?UXAdjXVTg<->2KMxB%Ry-v7-=2*@{nv+yi
zGKj9Y=2ybY%F<PI+zH3fWmjJ+=|M#Ujrgk4G8#ShSi0uA%LT8P@g`o+aSp3iuBPM0
z97UI3b+MEU9z2lW_r&x$tSDVUqfZ>ouWpzix-J@0L|0s;)xC1XN;+=zadi2W8qGn2
z2N`iG8*?08F#)h~R8&+%S6??l;$^E=(eYe%`2-I<(A3LN7wX3c;luYo6g@!pczzFx
zFs#0HYo*hU$OZ!)4d^7Xu=6xvJ0ja^RohtVXe)UV)@$h?eMavf1)H=X6QRTjNnqy#
zgnLZ%&gVFK99U(y^&6E4*1ldadcHzMQpNppu1NcZ4+~Bw{-?k45!shd5B$CG@zcEI
zKa3xel1?Ms&bu$#+j&c*E;VxF_=xOyJURyp3@C5FWc)br!0<Y&8kQ|#5(>x;$S`3c
z6pD=_vQZQS9)?UJPg~%q?9d^OFtgFv2-&p&;|y<_#x_xFXy^BX;D~JN_EJn`$a)A&
zXM_{DvNo=`h2L3&kife&68O!t;Rb9Wz4w88<%n!(2_BJneyN%YaWEqEoi%o86vR%x
zhN-rl%<XPkz3Tbu8X#t*t>j6NYlxJl$(&H=I2n^*uvjorg5kx=y1WK#T}UNDwKvKE
ztKc0{TC))kMa~b5ql)m8R;E0$VFF;Ipf6yi;(!xD<jYb+DCsp&ZF<98aA_gn8CA{T
z3DA)OCLY#1Ojv9f12|S%0uR1cV?nVZ12yYS8C!-C0m~)aAa(NY5&b<Wk&r-@vK|9h
zodDkCY7b@`b}2(50+re2ilsWP0kdy-&<eMeLJ<s?o}H}#?0^hAd{k1QM2bo!F(O??
z13R(3JEc2!3Q_OY!XVj>LCEV|2yax3VqA&=7T=u_!lMjmc@XD_p8*;?C*VkFyq^NN
zf{$-U(B(uf25w_#Mx;VBo*(`kT-cL(-QWd_FyRsM3SGjGh*VczLdEjK(11&ywqu9e
zI>88rOUup)Ql1n%3j%3`ofAx?u!+SGy1E7;>PlfEIlEMt=#i<=M<re$9UaQWn23yP
z{>@_mb80L?Vo^eaS3y0gdy~|>IM~6_+`^iL1%kkrKz!B^kNnWTaXy4sV+fHQ_oaCz
zz?*4EXsnrSVwUVUzKoi{Oc&9W!P6cQLHnyufWWF%!fhE(f?R{58Bm$;3{MK41-?n!
z0hJims~sYi+D$bO(Bu8~tpLQ(3R0xiH8e&CAtK<>tPwwkjs&h;2FVDSkVoqXaU)?n
zgt#ci19}KBqh=TgIPp?RAQMH(s8CQSWY0xB;P_(ztMZ+E)p)X)3l9EwxJN=Mb0_O%
z&#FFXkB_uPf)Zu@MoQOg8czzI1tzZVSST@k6N&-uiW&&ol|uE6pvYZF8`0ns14oDH
zSo{)U(c_Ax?(kM>bY2VS>l|<zq%WPc^MXg-R4FG&vL5jdOT;oRgODsJjc@5Zwj-tt
zA=O6_(d1C69cD=Q(zoI&cI~(ZxShR2q^%K*XrwevE<;iX31HH4jRj-h6=4_6bn0nO
zk$Xoqms7txs@`zxi3*=g1pP;yg&ZyqI=q+=@GMyRVt8hOi!j1hgbZ~AjqAl>Q+@-c
zh2W8B5&6X*AqzGG_kBP{cq9DN_RB+u;o1YawbJbL?Vm2qZ>>KT?+gvN_QOb9!j+iL
zb)+;+p?y*C1!U4RV!>E9fOf-(Q(t?k9(**dQ&mAx!U7ITsq+gX;MENU1^_}k2El}+
z4)Beqcs??^U3=n=i%Vn|egdAuy=i(B*|Kd3lT<)<K!z38rO+iyVW0@RDpHeKh9GbX
z9#8Y_ENe?kD>XN>{A`3^3L_;IXEIm=|4`$&Jg(K6xl`l6`@`?(_FI0#Jj3Up2`k$^
z`Oqq>QD}3nM4Mw@I*xXwdm=py6xNST2WW+GTEZkW{`3<ploTE7)lwX0R8a|v<_pM$
zf)c@{Xt&RT&Nx_Ar)OyeKEBnVR6am=SrDs!tU}<xDO*s07A0D<RNRKMGZPUq1T=Lh
zl^gpgk2Gk5EmN?q`p1v7>jZTul^>4e_7W!h7<}QCfB^zjcr;{s!&V{dsGW!8Flj3i
zXd@VA<{#E&n12c`>??R;I%Z%79Xv+ekSG~iL}U0gFMM#SR{|ds8g9tzkxLnw8R4Ss
zS@38`^$Cz%>r(c{4*+sx1QOFuvsAPk;2z1u>?BI=mEuuKl-fI0Tb1ky!38c=CKsf-
zij&kMnd{>+#XhckXi#dyRRtASWhy_|b=+xI12Pz-S(cTaK>6JEUZEg2Np7NE<zD&u
z-IH9O`tq_831xnRl3!iD@C?~K0FmtsN_Mw0!0r&)J@|F<8Z3R%sm^wHN)-6x%1lV5
z?n&vMWb=|U`QRxY%$O90G}j-o3wBOYh7NBp%uY<FoWy934VsK6jyuj?QHT_FUC8uC
zph{dYwVM-kAd4=gO1#s;{#36aV!UJkUvxE{YNi5)a^S*qfZqi^Dvm3>Klmu)g0p-F
z(@fB`704WFh)U2ZAUgK=BWeEwM;bK0{A>=@*Kaq{!6IW$I+n(sJciQJcwpeLZCgG4
z=H`11{7bI5koxxTLr*;PEY(!k1S4fDixkgBWM?M=+s=g})e0^}0a?KahC@dqoRpJ9
z`@eb!C3e@`b<I_cwCd4P+B{>U02H3rhx%PTh!V57oEI9cxNixSzqVe=(gvi{fa%4Q
zb7&sbEvliPFZtf!HviN@8aS<(5;Bvholj~je|;UTd|;WBkD7A~#px%uwQOyovd2ql
z)0-O%+&w80w8c=UH@AWd*81V-t$Su7y?9dzWo2l$k}Y*D^vqiu=!5UK3YpUn&!fvu
z>P6kscrQIy`WUz0TVGa5S-<>bns{n&I(S$&TC%pDCUSpK;iQ9eXyR#wl$pwJQREZ$
z-ubGE9)CmYFCRQGf|BqGWezplTIgBsWAA>wMMPBcDLN5dJ%~87A^Y<;I%I!)1I^N9
zKMk^vwaflC%Yo3ZXEI%L8p}Sk8!d(GkD0QMh3wq#mFzR-n6kfrzg_k}&)i5ezu6Lz
zm<q`$mzJ*$`w|xbZaj1v9XK;Fl^z~)5%o&R7LfG~Tj=@qv+0}a6_P$GXBhoo;Stm`
zC5u{lz<gx&O!|Dw62_0C{G=?pp!bn<Y|aRpTf2(xUHM<Z!Pg<#MKqz$ag>+bjT%~;
z==IIt(Z9>*Nck%xuBB8tqM4|?v6^03{~67x)$Robfv_U(lKUaiBfkfodG>fd=Dvj1
zuU$vaKJga~&7vb49X34F`4I7~+QLidC7vI&1GvC60;V|BkJd&=OK3Rw#)shpyap~v
zlEuc0Or5j}CRS{C1}r9(pst+2Ss*Sbrm3N$gnLn<D7=@RdxdVBem8C3-k`F4T~kt$
z>9n)P6RuzV?;HB*hxuYqBqo_p9XL0=Pv1gHP4#}_b*n5=JU3c9G!G4?J|Qc%G`1(K
zBIeQ)q+8irbH<w=cv5l}#PKn#TfeTNAJ6@oz8m{LYFM+Kif$Vs-UnFX1E-eImd`8c
z+habXijOwY;9G`LLIzvVT(-~O52W;>3~H%s=9k7;x+L(Xmr(7z8v6RMPighjE2!YS
zek9%rW?<z5OX<54{zu=A{+w#(*U+GwhY<MKlY%_yL1gvu5?+<->d`N*&@;nmcQn_x
zOY7*eKQ5!Q?_NafDjI3(*?q+O0N!8>e6_HKPPu&{&HiaCO+K>^Wu$6t{0#Sr!G)=`
zt)Z0?Eyn-@@7mJ~Y2m7RI`QWD^ul}PbjA^R)Jyk3Ji!LV*>^3XGk>#)7Ovh-lh5eQ
zo=?lb=PH%IOfT8p^rd9K;=yHf?mdfWJ!C(t4?lG>FOZ#$fjKPusVw_v^EBDhb=jYW
z?CfQO?0{E6WM`d0_OZ9H?C+Noj4|bX5!qSKXR`bY`8Rg`>6+{cza!Uo-*WlAo2)Tu
z^S*)S+Bwywbk)ND&)#(aSW%q+@A`4T(R=5piei`8D~ct}_>XD!3SvPqQDb6{#$IEI
zF(%PyVz1b1tSE|t^xlsH4i31={lDMLe!H{#X7}xT_wKj@2Hx$=eEpl*o!M#oH#+&-
z2WU}c8C}r#C_VbXuyK8kp#PQ6qF+qCmnM~cLl^fwhC2Z~y2Sr(8+Iy{6m_RHH5HU=
zOm_fwPVd9%n~KGB;?%q7k!A1EFT3yOjzHYA_zgPwyT8zHzPq2k+qjs{?=xD-YlzLD
zg;lS=`c6u0F5zzyb??!Yswyk>sJlE`g`r&Ce2#Eu0;4lId_*>aKJ5|+!GQaN9d84<
zs3;h8Ah<153n6_4<zgj9n0Gz5sr7i_OGcybQ{kbp?Mms_2*FI@8m2-eI~Kn!b%_f`
z`u6Wb7x716mM&gKojP}-;&yFm-kb$=_pJ}mu$_mh1t`mxtsrzp5DE(msk*v~4j+B6
z`iKzH2v=Nv3BTQJq5nSdyy|p}yZCGxI(!hHVV=tiT59S0X*218yZ@#>ih}vxFuIYu
zkDwp_>^SPut+V30WYJQ(>DoI~e5?MkmsOf7MKKF2MJ?);=U<O4v%0jJW?eB|;e+ea
zM;FqtJ4aH{&^DCE4FE<C7C$hbYB$u<B7Xbod}KH3bVOHL#c!|E&YnUWXKbKd9@|rQ
zBpj8q3$nShkxS)YtfehgTWIYEtEt}wgQ#d=5mm3K<k1QJh6<r&Z>^#Z2Xt1`992u>
zjesd-TkxOI(hC-OD5Bl?RLZ?<eJx%8uf;B-$KNWYKb_g12KOqYcHB|K$ibuB5vbT)
zM-RTdf)3rSJsq@bJ9>@ZqA$L8F3nn6N%vn=;_FBha$PAZ$f2)hS5S3rJ^gRmdOGXa
z?$p0~0j*kBqedr0;QL>f)2QKX)wIg;HPw=x+STySt1rZ_^RWHK#|_)xE~OjK(6$$g
z?c5Ql;LZYUKV+n~eG+WHZ!XP-?H88#IuZqr?NjDx+dqcw#~8Nr=!6Qav$CB>b1<cp
zw(W+eJlh?I7=F=cUd38pyP5vB^gWmQ#nP{6RQo~Hr+}xWd9(r}2guvJrJ9~u`8gfi
zWp^6cwjX`Eb_QKB`w3di9gjbhoX8ys-Kc_5F0UcznAe7;aYv$t7iLc7D?;~z_O!Nk
zqw1K5N*MV#yyFPf$tdFvNkhY=SKdyE#l3evOe>Zy=Z~13YoEUNT&4LU&ATz6Kc+Y8
zxEG4kE-}4<lP~>kI%A=8pmuKr837dyJUS7c@3fFq{^|}zR#puY=~Fj-)M~9ppnDK9
z8UeZhrjM01Aq8m#CdtHT0~+;`!2{h93yc=*vG+)tI%S%o?$NV5-E_w_^z!qQ=%e>P
zQF-M&jj?J)shZZnYS*%|HB?hwL+jUXQ1F3+`qQEXi)q!$)wIiQJJT*Bcc%Rh8b!(I
zetr5$YSiQNPrg*690LapNMb=FgA?maOo3*pL@_b(lCwr9EN-I`<lOPlE>zDq$|i0M
zib~ojVY$V5RJE*<u#N(ufZs;Z>)!aiE=QGV{Mk~uMRgE*bHkM1wSYPv+?lFZRnj_V
zco?W%`R%P84+TSB#k6wTUOEwmoBUB*@k?HykdPFR$t0C>H|Y>RXcr7+*VEi(o7EdP
z@``y{V+GYvJ6=bD(4D8j5YUMT2Iy2-y@f|F%IW0MU8xIqLigXfm`clQ=!=<NgK^Bh
z9cZ^fZIrwji#Mg$kOuq#U9jNLYfuBv_n@+Y^nr%$1F)ut1EzFfJJwMki0$Y^*n+Zs
zYB~Mp$gb3x@00yU1Z-!WkKy{h8{bp#b=tN&!c7-w+j&%iGtGR_6M44!0{9-q{i&Ki
zJhilHE%nUmph#Nh6sS=LbSx0M<h5nSS=@<Ot<u3iHT=o#S4*eRuX^mSIuxVY4Wfmc
zOKHYN?}cGh@n9O(x+fjMoruZn=TZ8d2)~6`Y&q#w?o5Ok7*KWzzYJq^Att(}<`D@5
zNXCb|s`>d?SIg5I`Fh=g0=j=tUl^Y|ROWV2J?_@fPJ{??IwV{_eTHL7!`P((Z2f_*
zaBIOScJRACHdz89dSMgCUrEnA`GSIt*mWm0it+g0|HIp3_@?8LieH{`B3*gyMBXA(
zK$Ab4qDBhVuF><Z58m^rN>7{my`sPUrhC=MMqYj%ZE!jl_|$6@9TtINEe1L!8!I-_
z^H0A_mruAlLDxplK-tJIC1EHH`3Zxtf)>1#1n{TCM@JF}S6t0dyjOc};Cs@7JLd4Z
zhI%#HP`9a;O0F8F8vH@m4Oi&7?UMIn*SuRwIs7p0&co#eJzG)fYb#7q)ZxHR)Zw7c
zl+ACjW&Ae0y@a68W7Q$4CWe!w42>*qOry))#5Lo)@$}S~eLK=$c%1<6bW<ILP24HC
z^yj_l0B-bt_sc#C9qTDXu3P~yZTjfDa^7B-LqFWF6E9ZGr?<ZJuLBr0yqNamMmC?{
z;PGajaxjG%#Oc~T61MNtksfetM@K=~{(o#c>uK6<h_gmN`qr?$1Ka);+ip0@XFGSe
zG8GaRTLw5g4PhXc1{ZaspLN@Z?qB>S)$!XcMjOg&Hqq%l52jt)^r5qRAErpKFjF^#
zK@MK}%ZdfmE~ki2=(;yge{`dF*62}A!Pu?1A05(RIFEW1&?oB}vOYpM>MIsoVtNfz
zOTLQeNAsm3*BAIOjRe+8@XeZoDGrQE@LPW3?hOZDjW}TBK&N$;MJFPqX4?>Mi8?ae
za&bEmo(yN7iG|q9^02);Yb@lxv*ISpTvNtF)%?~nf8Iic+P8mib^RYN%$zXx3VP~a
z&!`Rs)<f*Q?;ertFv4;9A1A0CB75$=8+Gm0Md7z9@;-NJV^GIaFYmtjfdU<V)FE{B
zpRS;B{C)c-3GzS>YxhHykXmk*M#@Y=xyJ$6G%)E}4Je|W?%$2d-d;&7{=Gzlm}u5z
z-|`e;Jq_iBa&^2QZ%bt@VLBu#U=79K8+N9pk1eE6N4-bW&znNMPU+7bhfXfp%uBzc
z&ky{77Tz_7`dv7PuyAu*4`%5rTQg7v5_qQQ#D2U}=T=@!`vJdAKl?$M+wNWS_l1}m
zrfW{=N1J$h3UAzH>+uHUg`oOaM{wn@`qGo!i9G7E@92^T=Fu+>>q?_`;x}3+{DJu%
zclk7WkQ?rEj_*NOxEU)*1&)Or4+*y4a*ks=uLF`GwqFg~d2~(L&Lb;P!Dl<K54q$)
zw*64Hou_Xk{DJR><E~`eUuN5nW7~P*W;(%I=A3EEx8*@*cV29H<KUmuYpcJe_txqc
zJLKQU3n<ah{&C<5w5hI&Ht<x)y4p<)3FE|5+1Yt?)qtPSKURE5Cw+G>P2?$%(|R3D
zJGJfwmMT23<SjaN`U7;&qSt9WugSo|%}j+{o`zHFTVgU){i<N)jYEsh1pjieqmk+D
zyEnjyeI=a<#h07w*o!LTC?Yr*{eUc#4dVD20fr{AGqNKAw)mwJaQFs7N8ZXA4DH(M
z!tdUrn*yy|v5MDBbfiw5I`RUPI(q+||Ir8Ueym^^SqKIU3rRTqsDst0!qO$nY5Z9e
znf4<AC0tE90H1m4MYS;W6`mKZuBxV;Mhv6=1N$b>H8=x>VE$5KD5W4JVKPcmx~lYq
zE+wG~8H+7V>B%@@`eB!U>_rv4@Nw2}^;DH&#A>elWG#LB>&f)V-tW?^-%X?J!d%)k
z*Bh#~X;-|b9wJ@+`YHu3=ecD}m$V<1Sf^HTgM!eW7v*giK?){W6-dDu!V(J(la)2t
z3O*JB-ha^``hL+Sy5=8?d=fDoaW0Qc9e(MzbnRn{c$6WV<}I)E-3~!n7}-F0`zt*H
zIc4@nHC?hd?{El)*C%V7eR+f;GKjK~NW{|`JhbnGpk9)1Uc2!0!@b;rox!$W`%k~^
zlX(&9d3VmCBPV`K*Rfxe?Yy=pD!8^!VY^s?DRUxhcXo#)wLMCp!1xW>y4aH8Hb3Ca
zy#sIi{PW;n&{yjh&_he!6;A4f0n-uJ&U=ndn0hDug&Y62xvgkP6|e7LIvYO_58?%w
z2(t5I_NEnTx@1Hf{i12oeZGFK!WEcG#QFm+CMQiKi!Jl>bY~(KD@IEH_QR+I&X&kh
zyIL?ZVGrm$@Km7cKsXJ)9Wnh}@RpGXHKh??rFu+(yg<@Aww&nZ09A}++3GSvhhgl6
zXVQ05r>k8UXsi+Pcqhi?S5KgB-MXsu^lxYIx`_dF@)^INIkV;wMlAN+XEz0tbrMKm
z3IZLDGsm8y@IL<VGb&rnm6JmoK6m1PgGbT+2aZx{^N)>g!MsI03UN7o@#$BzdQ}-!
zFz=4Mh9i}4&6_f;@$_pMvkR6&s?37)Rt>G0LMc}(QXn&jx5AD5_uf>`bAAhMpF^#O
z=yeg;y-~NRjymwl^9{U$9a9j)@7|U3YI*UbetXN~GY0ZH<*S92_|ja_;MP>Vx|+&)
z7YOzY_Bx{<&AV;}b>Rhf*ws<`+A3<zi_9>Evih}^l*9AS{dxN+LIp2Q+b#mCLn;N7
zVW)^_?7(=Kx98UJ7R|rBu!2f>`U$FG2LnbR_ElRuH&Z_Ern%{?{%W}Y)9D+O>K(Yw
zbSTc{g_ZiCo`HPE$QoY2_~opPYOCmPj_5+S{&y)Ixkm@}z<rAwPAuZwZEzcUo8yH{
zcRuf0K$yw9H>^PvwE`QK3ELlXY`_0Sw!McQ1zlE_X#0(Z?T~7<ofjg1$(<%_lU24q
z&9?6zu$|Y1po67s=dH5{Gx;7%HMnkZBgr{nh+9=VrfHR(Pd9TX0_!54Sn)CSEO0vg
z)f;GYeI@POx;HJZUdyK$<j{nE$Ec}}=@m;^NEWr_sf*&gLMq|~nYj!H?fSaSG;7mx
z)u<lVWjFfg@{efmwk4FGolBpU&!IkrooEP8b$n4ipYw9)q;C5ug%@nLueY#UliXNr
z(ahtzisu;C`h<lxZCg`uaa-PHSfJ`=_nzH&TD?NGQDHQ;{9JyX)j$@%AYq!_9$0VH
znP4b-aG4HlX1zLh!egwYgm!K`Jc;=_5}8!--~W7ues#+KsW<!s4*mgGpDg<P(=U}=
zYz^(zyQgv-oc{%{f#}LRC#tKfd0(z>5U^I_>o2F$+}ZO*S6;{P3Y|6XRNi*eP5oB#
z0?hZ``jAHR{1)<l{_7L?e2EQ|&m96Y*yzxaz*-D_=#m~@n*QAkwP@3%O*<Z52P0Sp
zOCVJyLHY<$0g#On^Tlx&TNafRxo1f1^4MN3_gR;JM`drUQk{XeylNexj`#jgJ7)@N
zuL^z7FHvhMbc$%?ll#)j=a$mE>u0JhpS@1)NBewmuo{h6{U)!1=izfKu<Xxog4kAy
zP`kdGcZw{a4e896i{KV;^_5eq)gz{TDEC)+$Bs`{2<-q~Fe_(B+{Zf*Bw#1UJN#Dt
z>m$3+i2iznVN+EdU2^|CHPr#UGmh=X3kSW?rN8o4U!0k68+RTaowS0dGrG{rJhg=f
z`g>omqv;Db(eB*I#Blz3Je`5Cfp>#E@lGjyJAb1}yMN*+?;?8<Wjl{hCL;$N3o2dP
zFYs)?fp>Di_Fr*FXlK)Q-o7j^cV`?EuzdpC&K>95xbyJn>uftO9)9^c$9CQ}JDo>7
zb|1vHAIrA0{Rql-p8iR&T|vYDgxQ8Q5@DkfL2j7RkTWFi9(J+|zIN`jG?^RzA9dY}
zcX8-@6Wctmn)_eX4M98bV_r{jV)q}oH1`ibjsCmxGkSc*|LCEm@6gY?kD_Bc@2)y2
zudJRz3wUwnU>>a)+iNuC^wEuNY4v(_ZpFMxJzD893yp+XtqHJ3;=MQCRS7Jj%;S%2
z;oO?AZ)zNS{Ae1rpZA;_H{m>*%<bC?PrnqZfenD2zu3Br>5cljT5c10)PdzE-r71(
zA5YDkGSQ(>LK0Vc=!KPGBP2E}Se-$Ac2Vr2+<gDvZl|%QPq1@HAs44!Ud;P%vBTol
z8}H$1j}B@#hRLG1T`?85;%#2sNk}EMZOd=KYy>(csRYPtTik}Q?G)Q_8Wa*sKPEfz
zemV?<Hl`>CEe_RvkKRV(PP-&E#u3<seT&r1S;a%!sfNNnt*CMdzj+xh%HkWafZt-#
zao!$wYs4wDRQ+nhzn9DX{E%`t+^<OE=+v9%@N0M*=gPIw>jP}M^yHIEmzPz$4KQ$U
z%rH)iM7bwydyJ!yO^}m!@88(=(=UnaNF<6tPT~U@EPJ#5I8aM$5Bkp$tDaqM+=--Y
zdys)8?bF>&=*T^Py_GIF^HLv`i=uM5!NXY){!AZ!Jr@eTsgcDa30?ErQ60zE@YYQ;
zY~d}T>PF@>B(nLN8#acWcpK=NnvJekArcL|oNB3dYeeYb2XV@uVXC9zciwjc{qCZx
zcsB(WTymq$b*q*;u+=<8FP*;xBF+HYe4c7Y$0OYU{y3Zpbt4b!CX}ww+38RO9PTqE
z086Tas(@ZC^kOVd8Ok|^!PnjLN4jd_HA&gB+qO=?c@MVE0#2-4pT<Ju4I5JHK#0{^
zUIT~2&C(FYk=LNtQ)a;2gFGSyy1-PZ%=u!MK?5R{{8p82z!XU^)bj({mLJ617SgGd
zTSM&)mOE;v$d_v>GL|G+R2#)>8BcKq1EwDn^3zc)$e7c~)`xgvyqK^-PVi1%V$oml
z)isfg3r?_+Ay(U6ikK0fOfQjqGy>L{wZSG&aEMB4LY}LxqtN-nE(T8r;b?B_6evaq
z%zVL(zB<%N)Rr|8;Dtrum}14=qIzfQ0pzxTeD&Q7j-=YA3qR1Ib6m^MGpv=sW>Dp4
zUbmolV*NsZIpivx7~l0@07v+%E8C>-@mK#>*^q>elj^b<9S9$7jD&A$BL;qhP_Ui>
zr&eM_qD2Q?A}N}HA`6Ce7}@v)`TEnTQ)v3Q(;9whJ5rhUK)U6Zt{#}yFhf(zH)SV{
zXIMF$ArZz>=SM-&C^`@Lq>48lLYRhr!xFJx<&!NFbNzZo!_h*;d8UC&96YZB>(_!)
z(Tc=D@Ug@h5(R-#1+`uRTQqreLPiXHL{0)7kFXAr4d0fhrc-!?6>>1rs?CExfh||W
z8REFFj?djd$5M3!&>2ufni7~2R2Kp)pr<MyTs0JHG}P`9K~D3U{&-9p0<nk^r&eND
zMvDw^zEc44^hcq}Pbh>*DvX3jVkHr-=GDZGM`2QXaZGLO2wTqsQjY0pAhhX}Kc+TX
zL`cWDB!*#XBRYiLw_*8yZm!BwKz?w8QjsiO!Qmn>wPA)BBqqAo==pP#q{97{vV0{e
z(hH%w+;Q&>sxuHoKqHN_N-$y&7Pu`}4SE<nZaz8!kf$5_Fe(<ty#S0L<T5VKzTnjy
zoX6`qc*o-wUT5L^@nTrj6T(Ob^T!rfOrI3w<?=3~yo_`rplOqiNQAkjS?7n>^Ayxh
zl}UJ|jS`w3RTRe^u$JZlTOE+RRBK_gwOtHqLIpjMUd%5Z`S7qFCJyyAqY0*;KK)df
zMlMH%U`kC&;gXsWG<2bM0TILOc<YT~&oG?)tZ@+GUlhKnKx8}vOhSyqXhA-YR#b&7
zzQh}U*rLoxl`TMQ2gN9Zn$57l%`9{}aIh6Zi0US~iYsjIPXavMj2#_`D9^<$9hZk$
znL(Ti1C!Qe7#WGCfb3|DNaj0$Th#-NQF7p!N{!sA4hR$87>)^(<;#yFSa2LqI~T=9
zKt7)7Ct|TnKr$6dO}1{Y5*YfJsCjnI(O8z}k4ugSe!#KUNEekc5<&tnAtQk#<qV$A
zFdv_K>Vdav@`C(?P6L~O#$TC|0aYL?)euRM2ESD0H|f+ys>*E@e5u>^`W>PYiV?qb
zh=n$Ubx5|o;-n)#M8J;h7Uuzbo$#9x2ggs*Oj7CHCMhW&=9{qmDCRCrh~6$dib)78
z7OjgU5qUO9I)u3`I}QntM##jw%<#LcKp%&PLy!V$YK&cl?2)KPKHmN@Er4H8Kjm5e
zlhDDii%Fgv6p)-E8bd9Jh_Wu4JPve6M*?0_HNm;Y@tTW+5|>g>wV+H|mtkZ?C`6)%
zECwJa9LvMs5!=>0kXR?S5eua{w<L3v&dEz8RnubOC&)IROW`^NA#U1@L>B<2Gz3+y
zio%z0c=+<nXP5Uh4VC87BH|`O(R~2Z6+VEGz(@p#dd$DzX9V4u;4cze4vqq*>PYxW
z4C<{Mg<h&d(Kvc+-yI3%+;ki(l~@?0T6^N%03t=Meoce2?O1-A9jTV!fq1pUvm{k~
zkFuG^n$WOlQPEJJ7Y$S+>O)C20X~tu1i?j;=aC6;fvJj*maVv<6QNsRd0&r~7Jxbp
zTp%|>&-j=TOcFqG+F4mI5uAR&0?E*mFr_#WByNR_I7X(S*7nzt2)4f|I}Mdsn50S!
z+UT1=Fzi?&*Q}XBk*Y2`@V8eF*y~m^@<ubN(s6yIrlAv%rCE*kt(Y5jjigSHDcGR^
zL5RMJGA@?G&%#!pgy<sbi1~;LfROaFNrLR7_fz^nnNB#P6G67v!BLQxqjo_E3>Kgx
zfq%YWCJ{H&Kn$jR#Eq0tor%l}&gs;y+tta`#WB+65BNBt5@Ghtxe6v}9C0o2W((uG
z=<3Pw*)!ONA0MUlP72efbK*{jPnYG$8_Rc4mO-b}T9>hE>yPlf=(jpOWLOF5xF_!-
z_C1E#Kqq*Kbm_ss55B+;LE^YVW~Sveh7B!|=NzXF!oR2^gSl)kbmA!6W7z+a4#H42
z7dZ6=Fo_GDq)iy)nLNQ8Y5Wi*uF|ZJ$QGWG4(bB@jKTOO!!zU<e*P$)oOb195C-0m
zfuFM7iR*M0`|~`NKZkW0!^ek9dNALc5_e&jF)lwF6imfE8!os^-_xoboVeJRHf$pE
zgkOeoxjXUMGw0DUeBAW~6VHPx3}Zc=xRPhUkPlq>ggCD9<6@`rmuh?FFwdhIHvW>c
zl`jSl8AumQI7`Ln&YYuQ=U;lRuDdL6{3YioKg^jmpT-<_I9-4*E5k2}?rc<X{$3K7
z?eSc9C!DL&fQ@H74byazc45q94u3Xb%&~_v?wOoo+ZCOT3+#M`LEs>UNgS}FS(o!K
zVi*g-^=RgUAHwJ{htXk29ZH9dK2)X87<(FXAeujS0p}e;r=NGKN)IUM&)<7GO-*s&
z6Animb2yFTZ%QGQ3?4{ljMaFG?kJ{n(gOzdcjNQtFi#W4JcYkaUZcU-53am(Phq!Y
z(dm4Jz4#%#`{w)V8uce@uyaIq6jG*+$c~cHsIbg-zGA3~>Ib2?hKF#dP2q6ta0v~A
zWcrBghH2CCsT-pN8^Y68%i!gxBeEN{6dGbo0~9mG-oxiejOQb=5p=!@O%#Gg&kQ!7
zdU;;Vq)9ohWCjGM%)}!QPIt=@*_<JHz|wL37e{29Aq(dd@WDt3u62xBpOwQOth5h!
z;|Oj3u!P5kotT~F=j#CxV}@G1KRYB9i5ddL5!siF|2-A*nGt+)w;OOuLs-CcMm2wM
ztCn|iz;>|4QQ3KX$P*f56$IcqM`x?QA-WhCjT=?+qm_tzM0U8B8rOuz=Z=DtU*k(N
zBuK%?)c`qBK<rRcVZoAXBA*>O&C>%?V!>;3(-!(Qiy)3_7Rs1P*gYg|gj|zR*twWg
zDa13%%p#Zhn<C73A~vs$NMp`DnrBc-K%pQwgK6tQP=N)PrZ{vK&}qQpOR>qiPQuoS
z03-8pZ!&JGxY8?3xzv={_Bs+<t#DA4q&nFP!HyvcOM%+4>>PLGHU|$#iOIF8bb`DV
zADXQZ(TdqR5sh9Ju1apC!6M^vvST4v7Fj|OJ5~%8xigZmwm^|F#}t_+MVH5{MXd;s
z1zTrfy#z)f(5V2uI!p=?`Gry%0Kt{30aAR-bf)8wnE@f&Mn^&lKshDTo{r*&YAZiG
zo<I{TxF~JXC1RP-9r5Pn0V&(&rB!O$Y}FdKRfTImg{$B^Oay_i=sd*fKnO`<NrXcZ
zaRWI@Fz6e=Bf!#4#$_8Y9@83b8zekj_3RI04R(=S6+A|g#W*%J0XN3grgF%FOH({f
zm&D1JP!}w$i!M!qWN|Q&A8^fhGTOA^4HMF`I}#1EJ#Ck3!suEKs2@X=m8*ysOh2|j
zcU+r~2h5Uc_N67tHXrx-HE9M8j8eh3-+~dNaQ%kaQ<@(4z69YYSIG}t(Rc?M@Bl``
zl1apeS&mMGn$`fl!NZ6q=;ec%3B-L<B%EQw6F4<ahI%sl^kB6jrZ!wHSXUfvjn9cg
zZS{dKFhgQ1*x~AxRwURy#bc5i53LzunfGLqt7oqr_S~SNcC02hVTZs-4>b2uiqy{m
z;u)xFAJV~UXjq>FY+z<68mWASWNc+NcAuJtn+0NG8#qR^G0aK5f8r^m2l7oD{2H1T
z0pd{#UJyfgC1MIiQ(Q$0pDcAFMeBvB4em$qp;XywL;{CXxhp4x)XLl^Y3n4Qm*|+L
z1}$$y0!DAO0)e*^J#NnpDr(0{v)p!&W!M8!I&#f0`zB?F=bpSsDSNis{bDg23N?ce
zt%d`QMoQTVKRcw%93yQ+Qx?)df}ln&I|j(dxUeoFYLTVp5pvQc7+QqrH4;umHQ}xT
z8H_~S5BOw8x<M9SqJxHkjlkfB-|jFWHrs7^Vf0%mzh!LyY(U{=#;^90wC4tuwPR&Q
zuN_>{^*~E6l`#Fo^5Lgo%`|-%1vBv)6pvD_L5x!)PNs&M)-aHaXi9=?KDFf~Filrr
z0wa4y)JTLWIyk+fwsi8|$ZX!asn$o>*{fW1BkFVP1K#|tOm1Yc{nPIawFOiuXKE24
z!~%*<8G@Lft9N4fwt%WnafT3Bbf~N2Q!aVxCzp3~SU*1wv%$`9zUCCn7qKR;<XL2=
zon_^jMJ<2(Cmbigw7t_%LU=dP!-=_~sFb!~B+@oiqo$;nL#dilW@F2el4)!?jmbZ0
ztr8>U>L?RMXTs!As*KuT3dktq%raAlP-RHhl-a1Eq|Dlrz%4>4Ig~1aMl!gOPc|AM
zsOenQsDwO1(_zp68ab58HX;#gorEDfhd=C<!#$BuQ=|;!YS1PSNz-EDG)CO2tTodr
zz4=XTG?nA5?m#9=SAH5vQgYR~_-j)ZSldQ8hEMTp%8=J7-_~zaDiriAq%6Kcqe2)|
z$}J2Y#j_>Blzpa=Qa!~1NsJNFbjrQBD2KYX3prGX8Fy@(8@gt&O<@l8?wp_S_7=%A
zi7hs8Qa3OHPOeNfK+i5Awg+M2V^@YKr2u|thX|i_@0ge1FPEn+B64gnCvVL0$!*Wx
zf^7_51Jfp_klN?9ws5T{4J)$1!m>QRZF5@jQ`qkhq3X!;g5SCjSnR7ON|79W%wg)P
zrX&peTz)cF=w|3hyY}t4UMK2_kqG{uJV?37H91AI#ITP&Z4FhOf<5KTUsCUWz384>
zAEfo=>s?LmfAn@YE|KZq&7ga4dq|QEye5`<Vh%(EYM_#8$84ZNEsDJ3VO?nGExRP>
zyzuThwCu4(ZhoiHU1`XlM$nq~OKIkWZ&iNlVQp#Whj*u(BCd}7N-+2O8MNw!<qFpQ
z=e?-UxdSM-m^&E^n|ISpTKUW}m!BCy$?PZzc0#a<8fo~)NSf|TE8f0MF8%$o!BpH@
zKT6hC)Y1blE~huYT&MUA?p;WCj4Pp{{A?5--TL1pH0krT3f8GOm+n5lgnD%3vgNR0
za~=KYs_CS7P7LsT$>Z6lOFo_Vqn@<S(6%&d$tD_m*IY&4pt27k4#`&XpywkK2T?KV
zEr)e%`-3m9ptsoeAPjyH7<j&X!%kGlK9R6wbrqfR=h-SbxK|<Fe%?UWXSY4QlqP+l
zefFdMI?`!Jb)&Yea+E*ser_4P^ywO5W4}5^MA?!^=*LzmHR-QwPwU)5x@G7o)UBYs
zB3)LwhW@eiUHYPY4kf^<*3#dXy-#1PpQmvDx$`(`o7>72IkRF3T{h=mTrumZPpeLJ
z-M|y6U0#ve{cy|Tm+7-|UA_mlA4<RJegJjJFIKQSm%K(Ft()cYNjU;j{ARKWoGFVz
zOor$`8Mu4wy*qb0kEX)H0;;X8r7u7Gie7&1RhL5dEerw|k|bgy(JuGNPr@a`;N%K;
zH95ngQ(`B2GSQ%+1F2W<9;$$BJQmDbMDoMA@eL0sIe+OT=0FORG!#`dc1&Pz3*prl
z-iU3+y8o5Y*FXEz{Vje_KQvZPTIur0;WxKIe;lSd1a2lrhTXX<Rj;a|$wz-g8)t8z
zlHU)boYuSqn%&#~;=#1`!!r8fkPm3}+pB2c?}loa$$;bAc1d`~!cJRo^W7>c9x<*i
zl8uAT14=68&IkL^7qcqpj9X^YiPwBjOSwV3_-DQJ+cGn|;f(&YdR;Z0c<uKzZ+RtM
zdSY)XD%6ji8yVKBAe+v-eKs9)#WcG4$;C<um*=g_lj#)C6Esig_ZO}c1G^W}#>zUL
zht}_{F-+42+Ws2Eue}(*&O^`1Gb`w<+h)^A*UeCRUij0V%61d>bA~Nrzg*<Nq_RH4
z_4;(C#qZJw7r2^Te_B6UU0y@~$8_-7CG1c542{!y$M>L5zu!PV`os71!PIiP;3qv@
zf4U5u2+RVFx(0!k^rV;Uw#y5*xh?`59X~IhP2;9LNT*M|hZb*MP2>6<qecn@cHZ}o
z(5cfNU|1QA?{k!I6ycxC-lub>KcId$E_}|>rk*bCcPuUCj>oCfAEa+LE~bfnj-$ft
zJeHP4V|yJzAG6F~es>>DTJsHE)O(DAi7Bu%-7x9ZcND1}kx1lXPH$iY;u!8kEMBmf
zuDSerdgt|bY2W?#A&gEmN{Cy44HfP_J5pz)yV9xCMN*91eFXjZXU9>OZk-k0l0{4D
zrfcs|@nJg+p;ONKCADi;Of@w%^uPB%rT;ws936ht!Rq5*g{=w|-WAte!l#67q5nSd
zJbm)f=PIwds+#_M-JL3K{u#EjohNX@VTsi)F$Ww>@7ghdwJnBMo_{^ISzD^M(B}D@
zT>K6PcBah>Hd6J<DmQQ7Rl}%a`UWcO;|+Hf^eCkKE(J7;AEveIY6xkJ33fiZ8&&Z`
zG>gx^U;My)s@+gai}=m6^O4=C(-B?W5eqQizDmV)XJQ17u)R$Qrc;#_n&erouclD$
zW$SC{hJWb}09ZZoRw><hW`Dv+1m4g)7w6HnJi1iAv6i}Z;Nf@{e)#U~>7#Gg)8JmM
z=*mYI&_b>wSfKXtv<*rd#q;sSZn-}3HuL08#}Ix~pSgH5O}K9^&0bnb_gz?`IuaHW
z;%E6PPZqtFLgyKJ{^^M&uB?B*Q%cvL-k%1sp0ij_fx+!hFzg0~!7s1@VGY;mrKMHG
zpKEXfe58EFKK1!*xAwG>J7jr0z4!MwR#F9bq8@s61syW79UZhwJ9oq)V2;Z-P9%9J
z%6k^BuiZ?4U!ogd@P4^;GVR-82=y-LM2jj{E7+E7ZeF<2eR1_yv~T-C)H}Z;EvhP0
zs+8AmqSEU1ROftt9GM+*TT|b{&UDSZXQ`sLl6n<%P{&X2RXl*oYAUEOC!cwJNt?G+
z)3d9-pkq7lP9xj)bw@0qozH$HDc+w+ue_}g!9xwa*vK%w!S`2QULF<jNW|PZ^8o5V
z6~Cyqrj}+*n?<9KJ(9Y1??UD4%59X}e4c(a$gr8eKK&%siTM1JFKOzO@2GtTJ^a<S
zZ5uj&!r7`5F@Nqts^_uJLykC*zcO|Z7r=U2wX#%o9-vNH*&3Bzzg|CFke8d6%U`2A
z$Nly0+l$&3hw}`F9SnAEK;=uUfT~J4ICcz|!8RI6cd=z2&)>G$shCzg={;oIjx455
zhj*dbzn|{&mUJr6!RUA4AgbF`NA)#ZRA-}RO^w3M<;Dmh*O`Yd;I~l;iRC7c?eK~!
z>+ARieGt!E>6SaB9k>gIoq2j{*=An%P@oh*!+FkeJ!ms`Hfy-U(2Mi?cGIvQj_O2j
z-aLYyxq3ML?4Zu-J`CP%CQmR#C!#??1X$dW&Ke2P<$w|Gl<o7_b~msLh&hlOd*zp<
z9_*}Ry3y-5jiBeR8BY5QYokc8Rs><@631uNj?Z}g&|2<zAYfVp0qZXix^w3P!8HdF
zH=#hW{&<TmjnxS;`RraikgB)T&{Ce_kf6_+AljpCe}-|ViANeFoZoj0J-gdw^w;5I
zX?W}2D!WU8exqMpwVHm?buZdjS4EX|)zl@om@4XYnYYf-^`>>MzIM)SD=gEyI*)l-
zYzZbf1H$OvB=D`SuBK^Ir_-TF9L!%zJ(_;Q)A5*w#}{C??VuhoRuePck;uu(p;kPq
zkj-0PHdbt;=bwI=E}w9<dcN&{@F<nPeAx<mm4^`Ded|M|)DI5amnMHUg>Jg$4qCfL
z&#gXq_oFI3ZR+=~;@~-a=b`SebC*sO#nXeWWO;A0ypJ4t`&b`XT98w-T&XedBo}|%
ziKMgW4%YYhbssf-v5M!)5wJ*d2(O=5&K(PLgaR;hI@FaPls$gln`Tb@j<)c_Gp|D~
zZJe=zI~KK6!Xp_S59vaKt{tv$bKCR6J&tW}B@<?ESiW*r!k^^W={Bajm9(ZY`*x%U
zcs)aH9q~E=-Oypt;7<<dOn-cAA=U8fcRQZ8>g03|OZe^mcYmEvpG;d%V}IC#I`Fy!
zGmHe!eLS8fEUkDF^S#D2x_*I;`GcNE@6$o8gMjU3P_Vrnm^1o-QI?Azm`8U$yNrER
zPrv25kI>Gsza#tZ$NP7ptN*dc^%*))oA}<i^u%7Y|A=Dx-AS6JnEmOR<wi^m;>C}S
zvDnh&B=(mSb*G<pA4Lx=dfhj|0Nj#R-ROjF`_TPM-gIDD^snU~(S%u#(Jc#}ry8oI
z3;P_a*tT^#32k`+=Sf|EK({Y?jW+S<1J+Y4<_=1E%_cgn`@ytpn?7__&%+drbSzXN
z;*al~3Jabrwgd?4NzJJYK{r3@HT~P~DL+4-_StVQ>d>(Ree;!G?<Ke`@*1n|1lvb#
zssFCcfc15Cb^QJE4|uBL5cemGBD;0#swDL2*`3DmcjqM(7su;WVk+c@t8Ni8?sSwB
zrcn@VJUw~cSl*c~on2nAw-w8)F3%ki&ja0f-gfQBWrXPt1avI&JLFRZ4`+8cxHILn
z%BF(u1=MEOb|j+?!*1V&N?%(+8+l|Ri}!NZtkrK{vnGB^eRx6M&|5~(hVRO0OJyz9
zlvaDfcEk)11nR6LeN|g00P<xUT+)g5;}M2icu_3o?J@U{u&zS4sMnv~kKX=jts2tD
znuhX?byUvN9te-~RLB=ID(I`(8@VCwNTc^|PfxwOTEP_0b2QIq9i9r1?jP}omEL#@
zx5C3SF}iZ|+5PFmZ_DX9(bJIy8wB?3N7^sogsBdMsq;3`DxR{q@pPW{;7*nJ<vLy`
z@%EH;KA(Z*wcN2deM~pH`Zs-P#-dGB$)k5=<=U5uVJ81X_)9?D^4rt(Lw-q<O24A_
z*G%(C@0Qn&ZXEP;dTsUB^!{4B5NfJ7)=cH;gIb!qX*sRsDUKTl{gV0=cA^bD0)g<`
ze#g_xWm9M|PlFWj=fyYhGz!9>7QRUT*L7d|L;s)B<cfJJe;w1u3;5Kxd)B0#1UCe$
zh!Ke`TX+kn?g#sEd3vLuppZ`d)d}>$+aJ=Kuf0tJ2MwUp&OL<|&R<9~r_b`^Z?h?R
zdgwCEct-+$d*-PZ>Fqb(r~MBcMMsV~ly(|1jQS7k>y9=oUbuu_dTx^I;;Kq-9$hkX
zao%VkU@BzQO8t-#kc?m?@~q~Oiy;ba@xrCNqV_c*p{h!0h{PE#h$C`~n0ec0Je5Uv
z;-TWb+N&KF%XyAlLN32$ZQ%#rARfX+$S%mC)`N4Y|3xJ<`$|34fzHLe8)mBM3&1P+
zA&HVG|8y<?CM&vpekkwp>i)E8ZiPzk_!H9uaHLz+eF-ZAtP@C%<&k!2pGWsyG>E?E
zGP~xVi(CM9A|Mp<I+xp@UZ#fP^EtkR*99zJtM9?hRl2jGznWN2t(=_<*iLybPj#WO
zyw>39GEX%EgJOi_>jeByh|a9%Jr|THJ+J#G*Lg#Zf{ka`Vz$9pM`Ef0^o^Ce!`+A1
z3Qb$68%FHtxPx~mwdLsx_zVk95hnA(R{Rj)qkmsHl;*E+rg{w73L%9*Ak~X4<1=Z;
zYZ`7G`fK{Sd;vYO_-&swz;5CW#+3C7=waT?;d6|ExyhNb=$hA_=5Jo1Agy^s;)xX>
zQxUI;z!b)+8ohgOCU-op<53KR_PIs$=uYSOrb{9<SM{I$oR!$FfZwE7-oZuPCqU(<
zhU}O`14{Y>lcs+Cox0AOGha=~4;ngXJL*U%)15!{)F>T^tN(O4eeuaxw7Rs6DtLOM
zV?jPUx}Lt8{0$v_{1McvPfyyHhlEzIT1`9cGK^L%Uq!M51Jfa$I(MWq$DTrSX3e9I
zKm1JX(lFIF<9?od8$4HXZ}DA6UJsVHH<c=RLmhc@95#{F&lI&I9>W8@_)V&=qK3+y
zEq)+bbl*Jn6Y@PL?azxY*Sp(4tGQvRudbtPo&xE|3+Qkcm%Xlcd$i}_UErc~G3@SL
z)l|pY54<-!;km6}lh@J+4D}Fg91peT-2@L$;I%D0JpY#$S5QfhR!Y#avMO4+wuV-(
zui>HjdR{a~yiTIKdO*MP?^*$D002M$Nkl<Z^*Y+bjpsUEfO*oPU3oO3f)3*anE3F~
ztDmhU@O;SOd4GWCCLZO&^hXEYI$Fd#KCoYZAfGX^h8I3!ai=vzxJKhAMX<7ko)1hY
zQMNz$(n=~}J>cr)Wz}l8#Df=W*aI&zj296L3>~js2ezj7zA2}kJf(LbkKm!<`eyD%
zD&ut!KA#=y_>6H8)RtFXXMqzKZ#<))n(DwV4zmNJ5F7d@iAxHz^HnFJW=kDCx#A=0
z$qOS9uz(V~8veu`48WdP`LP4bqSe(KsC|AB4Q|zyzFa?tI_I^a(|C#kAGw;nc^P2=
z=c3J}RL!Fm7$5p+mwgoM%MJ4t@10ur<b|ANl$VuD7xNkmOm$4(xKzRL2mTFL8&Kfj
z%*}8tjf3e8J2y;k%;k1TukSmEp8xNQwA&uLsww-aUrkjqwy!_hubJ;iFkeg^$bv2G
zyuj4Pq6OSr=kUyvFVIi^?|9mCpWR%4PyN~(5_|sXSLm#9r&9Nx-PCX8iqgoA1a^dY
zJV&}bzh$0F7cFDhi!ARr+G8I-EUL=6Ot$j~)<~qXb0eD{?Cp7Ydij5rM0?Iy7L8ka
z)@9$(&JXQQdw+PaqMOfWMbz=|H$pFdShgLh7wgt>!!!MyDaPBiLfNkWL_QMrJ#O)j
zrovx6ckD;O8VT&&&~QI2m>R$hq?{pfAHSJPxSmI(-r=G7s~=lLcZ?m#=O*l|KzBa7
zRCOZ28^iQBpFM#7^M~PT5$5x}g?JV3+!@io$jb8uhvyl*ND=EMBs@G}FulTODcsKI
zEu<biUw{^CBxFR!#!F*sNPk}RD`!aDJ$|5ze&Z91l^p`R$AI0yFzog~=K((iEW*6w
znWd@|f%G-(7n~#U(ser_Nq6yC5$Jd!{OX9#v~$1KD!z$Fb0$7GUp1gAqk(_0M&dPI
zOBN?|=kp`v42j!^pXQR>Fz0DnQ?tQ^-8J-N7k1se=c&AI6J65pI5!UqG;dk>g6c#d
z^R|UA(anQ@O;7G}zQVa};j2{1I0!%NyeIA3Zjg$v;awbmnD=x-{Y8~G%Sa(Re^e&|
zpFX#YN*sOcVLU3~jH)mbJfhHPupKs4Q(H}Mz5Wgzbm#%}`|B@PqY>YIGmS7R-eN<T
z(_$KwnQv`a9$3Y^y%W18u&{DVoxTY~ClpSXuAL~07f+Uzu2Bbi2rTuh_JHujg3KUK
z7Dt^~o`$V$puE&IY^fCYJ$f6BJMEH;t8cBdoY|^h5moZrR(*}XLKXHcQad@Y9dvsP
zR)0B;@WcG6IKHxVB<|sIA8(YqzcegdL&Qop?mrCMW0WGe5E0yPz|_*R8s{z0!oML|
zqJ)))2b9>|kK9TZoN;MrV<dQroiE`D2=kYjj}e6)JQ{%pYsu<r*LL85t?M(M(lED&
zLJD?vVD}3~d_olkVhRB=?|S%Fy6~)tiVE@(Y$obF8${E1b&3zvRtpVyI7$MO@g`v2
z>e-4r0d-W$(-vx%guwaA<4n|*M>xuO#KGJi3Y0E+yeo*m)3K&@qd}1v4QhvPdq5s6
z%Hoa$pF8Ozy7T@U=%TS#x_PiapI@_cbM^ThK~D&MM;<+2TeenpI$YwG7704b(Eqwy
zuBNLdUTx&qqWtAkTXyU`^UeqmVLOa@GNlPdPcOLE!GtG|TP$aurGfPm^6HA4Rl_WF
z$%SpV7|GU1z?%_Oz~{H5o@Yjz7uXk0VZFrm9N^<<|3yPn^<D5R1>qi6)&dWcgZpn0
zA2=2k7B|-7*<^}Y6pFJ(LXm;DTQDLh%tKm`kRVmf(>*vpBN$vx5k5o5LsbYt4l+qG
zEo|gKD(OUovk?kA2Br>lXF`7gRL4D<8gA5AR<C0m{|lyY1OCeDa@F8Vo?OxKh!dnF
zJgGv(-0{IMHqxBpaMwsUXlSFVcwJWwpIVuho9lEa3~tVu5^Gj_+g(LMi@F*nrLT8G
z)<{T6r7t}V%0#OZbHFyJoE<9-1-2`aWYZc!F9)5o!|OqhG`}>;C|HhR2U1zf)0)`~
z?2M%sEcYV@J5i=3E+!(1)Xj0wG(f;6ZARlku^D16(;A6hX@CIqBBf`NlHTZKge`ZB
zuMceT0xO{O;ar~LsOJxBNoT^H)^L&08Ol;?G`8?=!RlIk6*Px;a%A(5VK57I2R8YI
zxE!{ph<|)1j^%J#lRFNjg`XD^b3`#yxkN0F!;V-o4`6B|)gT`CmsYA=cHo;H2=irF
zzDb)rp2!7L8?iznX)LlvM@p&}5aj27vS4Z>R#0!WCKphd&z@LZQb$T^Tk0%@;;x5z
zYd!PNga~P%g?B1fHG+YbI-~wHtYX%BGz5}#nPF-pF=!gS9kiZ16SY)XT|=8IxnogX
zt2!A<O`sX<6ZtgLoDAw5e`=!%?h(7Y{nq+ZLSZUr#}LdN*UWlghqp89&mgzP_pf>H
z1f{pYbOsz2$wC1Wn@MELKz<AKTBE6)#VxJv)OO`Tu6j0@tBii_=VWAwxag4)T|gcR
z^x`!WSTCW=Ev(yucWtb%;D5MP_|F#B2RlvB!6@KEsoVvbqGn6Dr9@ZHBMpkBJ|fW|
zaj6i)QqNj{O8BUfbrN<A!Q64ptOs^@JG1^wkDGUYq(`r*5}U;s+%h9NhM*Ks8e6AW
z{G*Ygp-F6Q5V4)N$I^@0F~f6XQ%VCXQys?h-Nrp^4TTLid7ec}bSAJ~B4n+GYJYh8
z!)%8j2b~IZB5L{YMeIuCs6RlI`SU}!Zc6mZuolrB3A3HfuwXkou@YAuBuCQv8dS`~
z_v7tIW!eMw^2oH59sJ;d<h2_2K?GLp!U{eKTcH0#-5^ddubzFOWFCr&d3fR7t~fXW
zwk<B{*{D@leS%=7&nmp{+v^v|!blZGLJRF<oJPVT&FxHtv2(P9LIE?-nW*7yNLZK|
z8N^VF_(-};0~=Aky(3|9TBdFC^Ak^dxrsS|1r@Vnd0ckH8tMV@uv{C;ZwGxm55V71
zAsJlJ25%QD!&sdBlxdLo8Duz>pbs+Smtk33i(P_^nN+0V%-ul-sO7M8yIf{F>&6|V
z(76pYnV_Z;GHI!mmvjVh#ze5Upv*BwCFGuRt{9c53mk7?l_8m?tIfE;8{-N&jV#OG
zkq{>}hA}aD+HDRhX2*&tqS>K|HFDkB3N{x#wzeO(mVEfXX#*blO)oVgHYTW@kdYBF
zaorO~dK?^|(kT=8s2evCd^887VV7h=<E-+KovhY5oe4|h9uN~F2`5H765s!*w{<4a
zO9~;~!uYjyweC3}F%${q6^k}iq!7JRWs?lw>qto9CZotWTw992ew(F+ieiG{$I7@m
zO~6pqOEx2-el~#?ei7S_cl~zlNM+aq&HDCBO}W_EE@HBV&-8UFxF%g7?#d42XCRp#
zYmdr{X=U6|33+7ubhKuwK8EgW_>jE>8uk!U4=G+uN(AhJKX6cDaBvmYO{flq@CBtY
zDk0epQ7w;1U}Pet5OiKj#7U6BTYgDUGX>7+RNU?AWXy2fwfTdR7yovgQg-%?xe6xf
zA;Six2pg+by@Kwd-|G168FLiRi&zFKryr)}32uvo@ptQw`O#5yA=?WB2ea)G7k@UD
zeRG`h6ZyCv!{v=1g2Yvtbrn45i9AUMZP)>`mu(!sU==w0d4YRBXkSZOV5mDNzcD`^
z&A8{O`*HBF5;s0qmC<M#Z-E8rKo8yU3zj?d5!v`A4(hH-^MgQi!K1dxVf@VlrORdd
zxuI;o>^$|%(7Lc+oOBor&obcPSaA7#y2Np1(`o!f_AQ4wGv}!zw8u?6m&vkd(9jZ+
z_#F1j(R{o%(kKYP&SyF%XF4t;hJg>#gBj-W)UXR28GxxcBhH!Sz%F&l7BD9+JSDB@
zQiLhnm<GDZ=hMgVG1)jOTYpkKi_X7P+X`KfH;&T?uy3q_k^1(;QO6%iV=rMC>pf@)
z`^CY-cPWl$*!dIAVqbE788VQ@^Ou<6KV={D9Dj-97pA*lf{xE-dB+^b<u`%lGfyAg
z?D;h2*uz~uv0<#snB$JnJXt<?Lk4~bxQ<c3BRN&i{8?v?&4E0o8$aP3PQeD~smodU
z<+vm1ybI1^81a`t`_t*?o~m@7KX(BgHu?}ZJ)pz_J5S>d0G$(`Kac5-VmhRmr=oM>
zE>D5k=p6Z0c`;znA9~}5@a~)MscY1qtiio^N!s7L|IyoN>}eCC_@o6xW%7q8Rf4#F
z%I2QRl=e{`itB^8y4=g>37l^nl^mD<4!ra|5VveJUO2W5lDzI<D48gDM7GZw8)F|r
zQzclD2I^uX$2k%g@)6l?@QLw1u}u1)Z*^Mx)8%DEg7^kVM@{Alz=mgd?7bMyk+|^e
zi9WY_P*Kav@nW7nHoNM%C$J?Ohf5h0YNP>g{*I@3SR!n>L>7OfON|JiN70bLvefiN
z!Y++0y61sgX#BbQcyLohmO8XbAB?4TkzmBaL~!EStXm;}oD!#CdTK&n8@7c(GtG*3
zL^h5!-wFZl_1}_EBFf<ntUz1AMpI<U+NVrlN(+x`zlXzjK$^}2QWn8$91V2!(0^_C
z;Sd{k3VDsjI0YS4W5kLyxi0=ER#1E}tu3<W0u~NQ#TO05&Ab+Nj+UJp35W?9o^ifu
z1}{6km`#qfJ-GURSTnJuzJ_ygdIXwFX)=R&e55uXR^{Kp0UXFPf1KO~gLtJ$OcQtd
zZzCy?FcoYCABNlf@?GuSNDLj}k_-j$c`D*FBzgxMiwC4UET9y#Qm-V*>p*gh6qQU9
zUA$zwGRq98X=9O)mynUVIcc#-izs#7nv_CzMz}(?kzy*=NrbJHz_<?nWh8jR1u@xa
zx$2`|ycjbqpaW6QXG&D_aoXBcu?+O)FN{OW&X0exWdrOKm-?Ro$ts3N)d11WgEWJt
z2&*XX2~P7ceuozDKual;rq{EXN{mn|421l|`_i5(bs`ZTkmeD>?1Xkvu%PznAlRoZ
z<l|mK!CcV_CoqSXu;>zi1fUSdxF(?wEes9NHaJKYT&P}MQ_COt%B39s3U$hTmKYW^
zSCmE{k<i6%79dK%QVOnzOk6j!Wk-^koQ8GcCEGO(b~{KK$pcb8jl@2IE#yUoWbi23
z%)-+2OcNWBuDEpRl#inxj}0gU@wi_%zc4>6Jz+K;I4axr+&6L6s02g`s$5l`Ur%JE
z6Z8ZXOBLR7jl&E!$j^cgTX524RW&{fk25JGm{v;OwsmdPj)Zof>BMA}!NhI(j^4Jc
zY5C>Rlop`u8>9RigQwpwAreBe{j|Xph{AqB+@?vVWrkx#(`cAkDW>=BoYVD)om*<T
zHrbXuwBOFZ)cA*CTV#ZxrjqY8Z?$~dWesl!Reh&Mc?zVWRMX%#N=E{{KDXzm?0|>2
z(@sPq)!C-09y_F@;sF%3{8FJy54R~QR=P48$qVVKld6Lg<RoN-a*U6uSy=I{nV}*R
z03erN0&uHkpf?a`11xsBqY^<q)kuK-<jEjvR2mxSwkZlLK1?h!O~HDJ8eS`b4u!Y2
zLrTQNw8=5?ByPiNUU?ba{+U=n;^ru$lQ}kuw)w)gO{<!(znfaKtyR8Su3fr4*Y26<
zJ5wHi;K-P%FjnGHCa^0R%xxgsWaKW~jfm;qlg$7HwR6+rTe<4@X&0Oj@$ei_93cr@
zyo`9{b}W_afNU7z2^-AQAn~;kHrDgHfqL~3EC-W!L}YEz2RWHOP`I|0m%Qj8D=W{b
zj>$AIwejM*X7k@IHC|>&%+x6aMP)-1sLQJ&sE#9`Lmt*j6crXwHrpL9#FZG2TPCoY
zbo-}rr0;11heSC=Q^;+a34@yx4_LP?1UZ~&Td*ZlHb~9Q6u;)kXN+?wRrEdF95qkW
zNy;nkJt>D$C33Ro2!9*Ylj+55c$vr(J)$K=W67aZsp=zKO}d~SDjgh=FbGV1Gj5>h
z>e#@opqe-SdQ#9*;UF$)wdCrP9Wx>QAMn6wmz7o3JP;!s<togOHiPJ8yP9~-FCMq6
zWYt{EH47#B;p0(Q8E&P_?3`@s)}t#Ga_=!&zzK3k9DRuU%gND)m4HrQhcg^M6K3Np
z-Y~B=ysedY44>?mYRGMuNBQ0CevE=8lat#vmkRq9QC1GT)igoM1=7rT(?}1K()jl4
z#?-XfjNA1pF3O=UT=xEFfyVV<cG{@iHibFVyK_EeCn<N)FnEpPZNfl@fYT}C2BCp{
zU6t*cQu2|CW4noO%64tf_An6hQW`s$HhK8t(vSrkFpY&1C{?h7{j8i+>zqPrpV!(7
zYZHKpo}xw6T~(A-NL})a2?srS0dM>K*={c*jhMsF;VZo4bjvgtI!zw)6=sfsYKo(_
z*4Pp%+#Lj!l(-NJPVfr7gTElo)=Q_o{Zki*{;SoG<A~&jo_yvns87FMbkD61()#iZ
zF2Q|#%3?4~|86GTciTh3?AU1xJ)JT3WZHH2on4xz{`o9@@Xr6-bTD%85eLxjd+q9G
zfBeB`v}x03l@7u_F<>r%6EQt!!jNzC<Zm3m+#B$VNxL=UxgGLox2N}|-1hlOjhZ!8
zwD8WkwEC456b0*eSQi>{%PtA3FS>gUEqiPc<#oxY5s&Oa1-*(CPVM??ntbR-l#DKc
zVG0?+vI(YBVATkys2%Y%GO>bn3b0_FU0K1zRpK6I`!>1s=)}QP+*&_M)>hQggD<V1
zH@{p*8aBuZJ8+j`y84v99wR6A@GC3n$#+YsQ*kccb^bu=(NWi@4V&xe$A9>q6y3>o
zx~JYNP2iV_3|Jiu$ZN;8KXhpccNVnm>)7^(UtU3Pe^st*e>ebpkYR6qwT=!LQA~fd
z+3@O0f(@Ox(|qSx&-Mzo{U=v{ujzi1X!~D5_kJq2+bjxNn3y)HTIUwhpNF1IT?^VP
z#O0N1=$}j9r7z0oQV_O`VgGPoySC{|*OdG$f%*LlU!%9mrc!Zk5&fRwgIf1cIHgtV
z>CEZ()5tdc>Ds|3CD7fs_)U6i&36g;$usZ{jWrjkhmpJQLT8<ON&?}FPrpKMz40FB
zJ9ide(Cw+@gQ_sSk;^ZgI40bMCvb>&M<$RpgN&3r61p;(RSH%lb3hP3+;Y6tckJAO
zM+XXh9SNaWFmI7W)fx6~B8|vNC!gSUA{H-PN*z13r{Z>PBRT!+ktgZtC!VL@-*6eV
zYE|gN1?(AyU1@=th{?PGc+jKC{9^LYRQ%N!-iXaAD>sYEKU+gf9$84W>uYGp%_C^w
z6+@_O(n^Ygt@~dYee<(VT{#_(>`Hyk8Az*{4q@1xBPp97)KgFTj4Bszrgr;uRQbv1
z6jBO*l9fpctQr~Bu4ypWmJZgbFhyVEatFP_4>AgLVsiLx`HNW<^zXMzY5k@;ZXo;6
zMJM#6x2KfzUU~|JeLkatPQPWgtHMFM7SpLmb>l{OoyxoMjDFOrAe+v*oja7Pt7(tH
z`mI;d-RjXD%pH<bnC_h^n$BgIW@OTfUY*ybdk*konmGnZzM8d>o_dFE-&jXivhCy9
z_IJNtPk?>Nuzxdb1H*pLunQUX&e!Gi#movi^ES^0bdF9L-HqOLY`EccZTs1Gvh8Kn
zwEG}!yP~_@pyLh+=-&A{L$<&4rsp*je$ZeCifnEY>GSeA^m^%6w7IUD&hB#*jqP^~
zo%!v(E^HFRHZkm6hK*y`=?t4uv6RmF{t?9qTSE6}(~r*Xdn8R>KUd{l*zY*PNXEG7
z57VmZ^)!?_6i{XQ#wB$2v<Ea@Ru1h^Jdn=meK<|tFi+*B`Uh)0aNedoX<vQWEB6Fm
zfg9)h?`F{TfBdtHw)>tV>DV70MPGgXwLVl!`OP8X%NG8q7p6E`@rbuRU&7|tfDo5^
z%ZQ}Zk&uNpo@sXDcinvi{rJS=s7trb3U$e%rF8Q(cdGcXorlmVXZ?a3>|$QoT1)?X
z|5N(!<InL&N)D!Dc__WmX`C;=W`f#_i$?pCkG@c})m#|2Tz8iz-id|r1UL$|@BVu!
z4iDe^cl!FvZ@Jf)MeRGZS9wE*52Dk~`L*g;R8>~di_gAB@4fjURdO7^Etapn0S`YL
zOmsQfu>E7U{b{xxp@1vdDQEwRhVL>|Ez;Rov5`kx9_EkZ4CD_Jd4Bnw;g?U@FVOQ;
zL(i8SJ;8IogZ8DLp7cZdo=0v<h73?XM~CU=t8WK5X?XSd*OTH1LQQEk&Awu~Bx&iR
z3soneXlNVSIDJDTZ1en0E?vh1JJaR`8>xC_73Fr!qt?UP(##3p5OC^i>uK!=s}=5+
zsx2x{2u(W43%lBG<1pOjl%IJ2HI8<#Js*6iipOxjOI*t?TVG2zKE8w#8umDMC~iEX
zKMn3xNHe+Pr(qg52wTWyEa3+`x1~j^s;IQQhC1+@{-9p1==WTQ7Ot!$+-e_l9YUz8
z*}{1S-APPWs_BGRL$2sV1xyTOw`M~v-TVY>*WoF){Tl8B403G0iDB}DL`Um-2R4iS
zV%l)o&pjKI?LAx3Rgbalt19_fLiA~f?U((ZM<+UjU;X7~!!tWkHn^F$zIHP`w&Wex
zRj-szrhPgLrd|b|Xi?>A1p_|pf7yZcVc3GIHQYfc*R_R#d$uc~=^GZ)x|)sLfoMg$
zw;MoL&3b}XRITNssq5+63jN|(&8JGPsMZ}O+y{HMJ%Xllr(|7?_v|qBi;AmG1l%Eo
z!_ik?GU~jMZ{t(V=R~Ynu3vNj-(}>^w35^7)`oTHcozpxab#EN?{VayhwXY!BqT2%
z!A!g+Q8<wx<2kS>R`5T>pm@0Qzdqw6)rt80<1cCIlxc3`+_tz4jpMJtp%XEG?m~5>
z=pj5+aOmiRX#Ki!TD7v&J;<Z1Y^_SKUti(smz$T%U!yzQ{q^qKlcIP=!HSF9x~plw
z{aQDGTej5G8kSqsx`@VKdXDNul&@Q_8u=4{`D4{+yUL^(fi7bm+ZQ;tV=CkjwjJS=
zbACm;@DvM%z?N`hpO=?M-FtRrzpS_VWdr*KdY&K9^Jj*hfTLr!``#ldKR=(AFI%Z>
zimQ4<7F%{av<ua9PkhsCulz)A7)*5>b}FV7PwIzr(SSCJq}vI-Y2VKdr9I!=pL+bN
zkFasCK{^*;L~xtR&&b}cqH!Np_?jq!hcEZK<jDPRUbQO^+@&4W@qILRnV#;`xzR8*
zo<n;V(X$_wDa5|c8k^%sb)q+TWb5gxhtbat>g1N6lw(Jx8^UzYeW>Y7S?R{(EVdLc
z1ZC{cBMY#7-crwY!NsUU5C(co|G<Xl#rCdxebMpzcB0pB96|rRY8ahxV5guckB&$5
zG8Gcmhe)x<5U^YE0IKGl5SYdgn}tkZOBIZnI(#t&vS+)2G->q|h1#v4ow^><X#_p9
z`(<?BPG`{(9d}9KhY^dtxWn;U+1Jb}y?<Iar}<-j)EWusrF4@>*i}>GZ`-zQsBgdC
z?sT}+O~6cQq;cvcra92gWHyM@;5D;SqPQjPNcby-xF(!sPEM{G@<)TXv0@WF|KFGC
zii@vN1p6O6N;Q;d&|Z7-O?vOGk5vAC2kt|YKbxXPE!M3mS9uTJ{isS$oBF*g3_OSL
zJk<Sl?$U{(ct*k6chn;fm7DR#!`*%(j5=U%r6)Q&(0$TNZz(7iS=xdWpA9B?`#H9+
zaBP3yvHb^ZJHpPp4p-MdUvq~VG5GEISJCvTGw4h9%b$5PNBr_I`vqzEMf60+<Vx1_
zbw^Ju^fUuHN0*Jiif*{_&vfnOH<_Twcsh$M!LWF*_SE%9J!#<`bEv+?f73+4dj6U_
z34D{4zPMcJmDdT2_lSyyw4oW}zgD9W{U!`nBNYnZ{0Y(_TgpVPCjPb_hs|+97+zvy
z8ipy})z^_Ft!d0Y9q0jGBf(qfeIW{V!oi(T?DYEQYZVRFM<A5+DxfR=x_~~Jwt>z&
zzK0sAPypx83Ea6*bYEyX6P8Ncv@W4Bjmc=&fvsuu-W}+#ybhw4r`}DTBN=uS!ya;A
zCd;4=V*9|JZ2RBXb{>s5_qZOa<KUy?&P66{7oO19U2Ms5Q-8q;UIk}hQFr=D_fhoF
zqSvV|u<l?G!+y%J2Lxv9+&H|$&fK}$LZ7XhrC7J)^$`ezi+a$NGasjq*Uq5v{f?!!
z*{xK*{5hOE7ohue-5kkE@2b`-Xe*B4T^nB0ACDcLY=<3ruzLCZ?0=J8BH6j&W;hXa
zd2qf2raAm4Uj{LewzakXXQ_?KpC={c&uxs9zGE$%JryLD%m|H#M)}=0KIB~s2fII6
z6xp>~7bU4j&u%o9zez8lEsqYwsk)d7x#6l?giJNAm_|Xc@r;tUc8z}c;Ef%NE^B${
zNkZo?dLDlMoCPXt&dj+)#~;CKH*~(>rE(Qry0h))1#HL20Xj+0Vd<h}iY?-`ym$*i
zN<bxyKb;&s=Q(=LW<8Ix=s9opd^Jx8QcS%xW@t5_h=$+48?AYJC9U}P5}&9j7!bSu
zq$jQYxQsAufl#|n+rN|_sOvsnL*?Aibp2sZ>dK7@7Gg>;>B4*^xZC>`{z-Nxn?ADR
zCwjRbk0RW1PJjAfYB@a{7$Jy)LDuo3I`X=K4Ltm-XRXVfdjG^*rGzyRU-GEd(cD29
z%^lRI-qTZCpgYc?t7f{!35j;v<X{Bl#<Tm;N8hgJk%cur6u@p`*oO>zj$vw8-6(<M
z_SLqF4dokkoqvL-La-*{t2q^_6Eb?w_Vl0k4ch~BKA|cRPxnN+Kn`3R!Kzz+d%AYW
zFL<rQ6#8I|9@zy4kaTrmlYB5R)J%`-vOB%EZaUTQr@0X->MGUs>E)l$_Z3TM=EkM;
zlWwDERQn<HX4yA<28E_OzRRBU?%MCDn!n14&wQsFbXh=C{k%!W2hxLKzXM0n_tR#o
z4ua23T2&9-A;#iMv}0IflFy$V*L@iur9)%O1IT1-Y9#mqH({O{jTN(YB>dADaYTy|
z8u!_!UZi*4cwf!YA35ew+G)g4>OZhAtzDz%kT6gG@^i1bjH@cE-MB<@bG>bql83LW
zm9F$|Cgex)#QF#Xn><VnpjU_n97F$KeDbB*uGxt@3z*J8=-#Wly7ubRQ(ZS0yGU?q
z83GoDE?wjeWg^dnZE|4i9NRH%5wv}?v+DyLnhrctA~s>oMsOG`$MB2j*&{+v=!1%z
zPDo|3CHUv_u<VF`>_rvdt*2SPo#qo61p^{RDsqeSX~pA<UAn5}+OKuISPh}Rj{Efd
zMw8830wtJq{#qy)+s3siZBy$6;I^1TvF-ET3rlFmqD^$|KfUq;izpc2yYVPSn^rmW
zw9!beSX%=SZE`x4c=JZN7v_7721Yo7bc!g&KS2}2)(HrnTty7*yL0?Ny&mLWe%m`U
z>~4n5;58A~2VkJbNCj+o###4+ycKJ-?VDjc+s%(CWqT{rcA@*w|11Q(7o<V)a>8O_
z(<F1TrHLHEs$Fhtx_;=d=<D(Y^tZ)tnG^)r4G!#)01S&POImeT+dE%h{f(w$8D&+@
zIvDOCAYkyKj{g;A<*KS!&tJ{L2uBy50+}>_ibepU7yvy}3TWx{qDym)L|isl0N<Kl
z0@2o)!EHZbKrnC?>T-28Ka;r^k(ZyVKTNKA6hY)*S`3x^U>f;mo*4(sq7Sk&5WG8+
znL(`U1jQVJql9Y;g=+ly<4wO)oru+?WmLh71`*I8PMNGLO|L#ZXy5(zrh$V7&~ZN*
zL;D{x%B8NT&~xh8midcQex^DgF3=K*;u!@4D=bz-IQ8sb(v{awq?_-#miF0iPnz<@
zRF#ho(0Lb~LC2pkMy0>_^ec76pR!W@=5gLdXDU5qYQlt_YrsU8o^1O*0ozfr(7`~s
zob~v{sVAzPAA644L*?O*%`aa&dJbnj&o%U%Z0PASXyix^&-L#5@4b0JBrk^JmG+p9
zz(UI$-eVsH6SaDt){p8cYSgHM<YAXa&Dv_}b!tDg4HWAmvUs6V=?lx9x=Pf`p<C|^
ziwo_xcMU!i>=wquveTxM+qy8D9-2_X(}VSN|BEZBq(>nQ>RCudyyGGa)|z4R<oE?|
z|E;L3qbalXa{@YGm&Q7NGe3#f*<h$2!~fVF@|sb`zhIc6o8!@?qkkBUJO`uv*@kVu
z_u_%d_J>|vK?B(KfowZ=o51$J7_fm1D{)}L`y{d5umQU?VEfNuJ8uI$;Q+^WWBLYu
zNp5?T=APB@u)O9;@C&o^RY#$QSA#ya;v?!&(1Cgubff}4dD4VE$*`Ub>*c^886AmZ
zc{HM|dIQbcv;sLwp|Y9{w4!n?{jlra+z~0FLptqD`Pq5&$-0?LqrG+<k4BX7ZjM=-
zmT}93_j|O=Odi!tDehr^#G=&Mj6V8s+RRhqGiS{4F$YJFs}JNR>bX6v<`?Lis#>0+
zf(>aK;PUiGY#PMT%+DomN_8YO`=F5Y4Z}jlWBGKvQ_lJ&FSKk&nA%vhU@>9$#xqa8
zpmf_~pOJLbafhojBg|2T7oL7q6%M8V4mjioR5Ex#q%BK$D&UzXU$pX!f`Q;a|9XzT
z`$iAP_2jpDZ0D@lP@xt#{+D-)V8mj?$eq;G2i9=l%m@ij{_`2aR#e!xKkK>c9wP)q
zPg!7?vUt|eb2QuDo6pM-+y8p+qpEWP9k8CFYxgd`?XNEyet|sr1&dR$t0hWLSE)22
zsjQJGDk)NDNMKZ9#AAEWu21Zve(m`|7zKk`+5F&b&)Ygnc@8-kX7k8KVV_pC=cEIu
z@A)OP@~OpCy+RLxf)3k3ZFE6C+j1IrZYsgVH{-%1xJJT;Be(;)7pik2+VY$AeHRR*
z2PX_tzfn82r7+mO3_~c$%cecJ!};dq#MSQC{$nxq;xj~^`ol0fV@!8?ffp67TBqMs
zT{=FiBGVz2H4^<`J8w<Kr~*bM?z^Z&{YDLMOD60thW&+M_yLBXY#7Y8TWq+FM|FDf
zAzV-LLd(-(J5TrdY!9LHd=XV*;aIXp!b*+iKz~PDG3dePN8k*J&IQGE+wjxq&YjOx
zzn$9lq3#Ckc81->F#G^RcOaj)ZywZs7)|2oieQs_+x!=)ghw479XX!P>T@Lhd)bGy
zmUnbOr$X+e9L(z~UUL>_s>Zj0CtW&o3#8XbDAQv7$>+uJ!-fy0Pe1-5X{RBKA^Hy3
ziCA653otX@kqDEDe0bAZ%27m-u&g1ycVTl(rimSh`yRcW#+^1Hz{sQtfH;Zs7_jzX
z`LY#(?T}oRco?U1*G_6$0dMx^`h-MI@p7VgM!~=xCs3l}f+>Yf8#lQEapGn7?p>*D
z^%|<;0uP304|v!nUQm}hV{HZ~+VJiU_zfKlEX)ap#M0r0nDy-D=!uG%sc<hJ0(Sms
zmt=}vN_<S8fv~V&5mhbOtfn_oVzf;l%R8*y7}Hl~+>Wht&3a_U0loXtTj_$+F7-ba
zI6sJ|IeCBM%JwLd$9i*TVp&<^JZNqD-u1|>bm5to@)J=*1t;ukT44G|;=!xnt2b#$
zgj`+QF}EWMgy8DzXryQ;(VY+9LKmGi(JD%4UB5^M3pS!k4Y3)Cgg6>Ze*V|-+6MXV
zMmCRXWH}uI!SBkaTCV01ieLk~h1W^=&bDMeS!(JdsD)A`)}MM_qjArJH`BPYL!Nb_
zR0ubWuVKxDX)N@_C%bGRn>%EBOin}5CgkSjP<~-Pw?)250vmZF<k|Ivpt#@K;58Cv
z0faM5RePLDxxRe8LFUQ9P`<p08wd@GM)8b-K`0i8E?uk_Ihsn~AdzKD6W@|eoK)kc
zE}lm`E)~3X1M4?Z3D9$ShV_K}RM$wPqH`3k%`cS;y$)U!?G9L?2jI_C?re9B1c;2n
zh~i_QB`VN>oF#ldi3%AO5XLTSjYJ$1qWlx2M}wTKGvV3};y_vW`Pr?p=lUtl6xK*Y
z(-_bQeSjtP&5cV2VEp{Yk^sr7=Y(2E$uPmkVN|w&DGotaDyTPkUP!{D9O;Lwl+KX|
z$`L!veAojUgUdK!UogNQwKe$ccoi?e%p<IWL+7IDg2=L25>E@G`;!V25ga8%_yIQ#
zeiW~54;JN-bYYqHQYr^hHB`3Lk|^67Dx;;+$MuN~Px9m%#|McAQh8M1WBYj+Ej#9R
zqME=AdApA-3XfEItSTa161MU{UaBE^C(0*W=^`Bft1QviN2WEyItg^8bnt8IPx(0m
zhBtZ%=#158V0z<KEHo8;g?a2N6N)J=4NBM3)6I4wfXGi}u|Mi~0e^KRe}0@7$72nJ
znz{)RHfq|ZQA(1yBay22!kwcf3%~T0O38v|j-1R}Vd|$#7sfB0d`xXLR*>2u*T#~w
zJ@eId$nIec)7~-T$idXcwi@i-@T|quM$jLUmaB&y9uwT)HJl;^2tQ(_nG*gfP+L*K
z2U8oiATp$3l(dU0k9^~5b}$6rysA!w8cpC9NB}Ow=vPln3#gF^2fv}63D|Y-Lw4H@
zl|rKy^;I2GqY{eBaEvNDKP#7>VX8B+xteNuSI5@rOh7kRBfp{%DeLynaQr9%aF&E9
zJi%$%*M?Zw5L$Q*^rp94nkO4-e@nBsG4&1erOr2@x*13|oF1wxDxAp<h-M`W!a^A}
z9RMnc+H#F2T^kc-QdmBCi_AE3P!=eaw93Tvy$FsYG=n%%en=)pO>e+*#RPv6J(rl{
zaYbhWJTyIDd7VQ;&Xn*tN5_J0*VtI|01K2cE(4^n#v@3Be7&JH@s?7=JReerBN6Iy
zDVL`@)T~XDPIW*Fzb#6yh(9TGB%&Cbu8P8o(4+-{n#w}RF+JOYTokHmQ~54bfffVM
zo=V?eVU);EvsMMk!bCKNk0Cn^c|s!BSgPSoxd|TJ(ut63P`6;i1bAYz<WPx!<QimV
zNyqU?92^U4l?7U;V+Nh4EjIJfAuvZV1ZK)Nc_AO2i8^;wgO_0P6h}ik6ItA1qeEf_
zQ>K}3#?gsD$H3GTaMp$wTqdrQ0DjUH9T3c;61BYkEgS15@|mIu>Lg3G1XvdBi5MM;
zpnFU?Ci5sflcr_H)3MG*W6Mj&Bj96tKOG)BXtq@k#H(c~)uDJSx0*vUs~&U1%@vEO
zAf<OVMs*^Bod)10HdltrMTHo;i`E8pWK{6w8bmhpMGX@N@PvHs1YoTM7F&AG)>tM#
z(`L!n{IZDm^AJx0DCXEF0X}IjRKzKn+>uDo(=@~a#X(sJqMM*2t#@Z6atz`Mje8Xm
z?nrFmsgC*@K98pmqZ3TIRXP;VSd?<LbR!WRiDaglOq1cd@>*PEYg-mwd@aYFTicH<
z!&B*(w&`Cp9<)1bAU%D_K?#kQj<T!qq-KtDn2*hd(v%jKZ{mc;@pyIwHg&rbR!;tW
zox;$64J)X&K%!$2Xpa3fiPnMw+d;8ALM^)FVT~Y<L@Ij@CMZCy8%(o(3*bk9OiXaX
zNJVf%eki#OfIM`zcvlBL`j*8b6WP2~G>Z>tYx)j__{OwS$3r?2AczXEE*VY~ee;KH
z+txLW|9AK>9Y1?s^J3}n38N9Nwx?DYP4md-=V{YFJ7b#;zuJ8o4vEb?Jw!(x_)S9G
zPKDGG&>=33v*ZV_F8|1O0g4Evj-z9%Ka~Orx+xc4ajrPO0f$WUXRs7HrY2NZBBr6H
zZ@>UkBkuHu;kRgA^w^ONUE8EPJKzCK=;v+=wGkP@Trd>nT^(6`NMaVB9-LFamh+ht
z*|0OFtp?i$M9uQ^*aSKfg5)9iV`5e^JU>-SOEs2t;d})m{`GqdP#YvH-%s82DY2&M
zCAS2L@w^iU%Z_8uH9Z52mQ<fi-J2?|yvR-xZ_2Y;(pnE`Ud5l<v-+>5wfVWJY_Q3Z
zhEwbb;)s2?>ZaZBfyxsK&vwa4e%0KyPqde?`y!i15wM;hoq+WQJm9bB^%RGUPb6K1
zU=@dT5;z<S3pwKkU_vT9Wl|xIZUd$_0M{5Aw<dzW$s<7rYzwVMXQEbpry~!GG1+yh
zJi`h#fk`GZq`b7YIh~5TU9H&)AW;a8yEcCqhPvptV_EqunmuE#f=PPFut6;zHkfU=
zknKb1z`kSHeo4oL&2i{1aQp;1#K9A=G0aoagNK!H{5%IXF96eY;%n$)@)W(&)iX#3
zevpA5g2Yvtb+^fbZYX!a!t@lKMV_R^FWU#*Joe{kRo3h>l5$5}`y~;E=c}$S8iuq<
zC$RHX{Q+zcjr;AnsvPju+M`*Xqz7?5lQ`%A8_#r*kLwst<A)$|IWAk(PtFHV<Vjj|
z0ZmiD2JwfI#$U$w3J38S(&A5vi!PFeo)QnjkPn;0)}uKtKQJD58T*s}&BfPse>j@X
zn|Llu&!Q661#xyC!{*WGA0Fw#pyyZz4|F(sdz`}M4^J`dd<O<y0F!iM!eGNZr~JlU
zdM@R#ZDaWg`EoQk?2{ix&(CEzd^>;Ue70{ioqg#!oYuCV<;3T)?MJZfk{-zRN!$hl
z4>%35Bbn#eOU_p5!9xeqIR*?o&u00+1y6|!Pf4R3#$Ad!kVUg*&Y@#}$j@u$3BAGd
zf=kX)@!7NH^HJD`yJ_SjjUR%JAHnpv2eRnmiTu3gfUhcp=fxApsq~PcgWR}=9nIx;
z9(NYBo+x+3XW<^>x-_0)2p%1`0c<;9=X2eHa=14o4xXrslD5KFMjfx8=s%z@ojv{x
z)stN?cL5zX`cOLkyi=4f29)%t)6doM`3iQ3n~s8k=CIL+s2}ux_s#cl2?^|E_Epx9
z-n&M2fIxj8pC{lyA{)fpPG}5kY&;Y55_3GSCKgL#j>Znl_jsijOLjzdl=kUKY{^vV
zc>`2t`K7|e#FaQ6p6bc#Fx6@8SN}_penSGpl#jT3M7AbV?0iU)AH0eZ!Tb!TO`9^w
z8V&88kMJ?kXL!d%i%B9=(poMkyrBJP{`Gtt^sz_Pu$ail)r)Jr>^djP6S|uo{xkjV
ztjiJ+oE*Qkp=e0~o-f2#S+qHukBH`xfE=!*{`Y$ALzjjl5;w1?&6w1v<<Sk~XJcf6
zkIs%8?s@P=8h_3e3LR@Lw%`k-{u?Hg75t)hZ8(cA1yS@vx;Be>I-27^E$5q`g4&=f
z${Am=#+O8Mc>M%E`QTQD264s_*?**~CSH@2OA=3;t`J^Q?IhhYuT5=5>hgrbRt8(w
z=c3ux)uOpbPuClGU~1ZQIfw^*^v1)?%|{jD1kzq@@={(b<oV+fiAe8i5_`Fg8pHEl
z8p%c#WHNVr=w(Uic{x$Bble0Q1YG@bosv9-WZ*~|h3(?F5f{1@BZ(C%mkTwRi&1>M
z*-HZ)ga^|ok!<Dz8Z}v>_LHV=I7T+I>ap<BzZFy*mMB*V6tH`RWWmkm2;!1<kung$
z{eaPldOj61n@`2W5!<==JUMqRV2f7?G9WC3MMOuUF-#88qKUIpuUd_vVCJ+iD{NzE
zDm*i%v2fh>ui-umhh)?%avRIl$2^UiV^iCf=aZB9M5a3vu}pvuV<CF>0$p4mBsJ3#
z_pUnTr9GaANxnZfA|*;hpd<tNoBGr`QdZuMPFdXGXJZtA7doQTfc76C#C4~@N^Q-=
zdIadHXnEmfb_$~s9z*u7+6wAPZ>amAm$$JL-0(}e6g?F!3SkEfe&|%-giLfO@WV$P
zvCBi1SOY|Q!V_a59SMt;infuoNYty*a+<<|%*p^aT^?R6(LGVHMC|xEnYAUp+~$oL
z?iI5f!m%1|osGBoXt%*3HK-rPMWlX3Y8A#XlBjWkneI%8wvnbf&wm?^&eH?)=J33U
zD>#XH4Qf_I_1M?2Cp>%_797(ZFsIlEv(AOlseB(_SZ`!-6zehY{;$UXbeF}zh-7U7
zp$`^ds#7nqg9DAI$}zE$$3defS>k8`9J54i{Gpld<iz2az#%RX<Dm>|d3Q%G@9xOX
zu2o+aHAg7aXkLbg^ei2TFpZNrD#7$-mC<sw4=azxb8pM_Rpa?2>_Guvp@dAIneoQd
zC^Niu{SrGOc?J!&Rn0~;-pV?tgB2;#DhC)&C=l<;F~b*<4@O=*b`u*%x!5>Cci0F8
z$A8r+yfsU{Nh{XCJ~Y(0n%}!n88$+bi5vGLBBggpU>rfi{1`4_tO&Xe2-w9@k581N
zmtvHR0w(#RrZ;%qMm;ykp}|oyOxIw(>fkuc0MlBAa&I_*g>0#-r|P;|s;P216nT0b
z1qNIYRJmqA5vL;&G+7JLe={J(WY@&;=Ba%uS^+nzd@|?IRJ6*R)Rw}@f9spRGUH8c
zjZL;K&(sTWuSWS(f|rmh1acL`;MMP@AT)M5nGHThDIxnPBNJfj|7k%OdYAl21_m&h
z+YHo{qryA!D$TN4-qGyMW>Z`1+3I#66bpem{6u&t`$PofK%P6~j|^s;h#AT>6rjf;
zFx1c7>#^`Mpl>Lp2f(O=j3TJq2*n)LJz`4?+@z}%2R|c@aP+_^MNM@b)$qYq+1#<p
z<wcpf|KHws09sO0f1lU4y|=x+?UlAmS!seaDZ4aLnkXRBks@8N@QETIpn?c?K&<E=
z5l}jaNSEH1?Y;N@`geXgb0(SGnYnZCyKi?<^4?66(@&C_WRlEW9aLanRpG@G@sI}+
zDW%h1=@C_%Khw^#DVf1p>@YNZN}F1QL7+>kv0{wQVqY<G|66$UX>4opC$7GVwNcuW
zd$wK*)aGMTamK_F<^tQn8Woo5t{i1SPRk5-=m9vMu7FefGzQKM?zLJ(Kjn(bNxRp$
zrX`laK@^t5ZU9OXj}>T=Z&DtzC?M%{`ZOJu)7p*!gbZ5LD^PLT*(@x4g`ZI`s1F`K
zn0sYwYcqGA_})U2x5+x>_cxl0y6Hk&v<{?Ip%kPfJbR+V$wsvY!#Xfa(Zpra%mWL|
z)?nEK1B>=-&g9oW$0wL?os`!<FKv(co0ZpEzFF0V0D3@$zsh|5eqL@{A$fSiG6}AY
z+zN?8qB$!EsWe=a(zn9L{;%e32eP%6fZLul?OLrcwO{jo+t9qk?pZk{R=N<X0z*K0
zqCoO=VTE8>v6hS4fY?1CE{>)UH9l=zf902<=G|C2m*_RDc<6A`zRp7PS{^<h;PM=9
z%SmZ+d2%62>&M!4V(<Vz<ggyuR7O9U!R7Jw*}S|Gil5Ld=cNkq%3|}Su;kLx${)FQ
zM~xm6N&$lw))2wO*@tpy<{=c?oOuN_jwm9fqcTt|^@kY>3@FO6IkOt&#J=E-5B|I6
z2iac#jCyWthVbkSq@&y{M();Nd7&j2p${5W1Qymwwi3zZjq(AnM--Er(~nZ+V*Yy|
zS{Ary<ZtWt&8=TItycRmKd*Fd?9w2uAEi<nz(SfZq1fEm&~sak@a2+~1fn`ncewT8
zkefPg)Hv|vL;1}Ed;w8lmIk!A3F@@{!ABk3ZoAOu=wV)A<h;iGFvy>T=FW)^#Nojm
z3~-TyEzu`;MwKl1Rfs(NKa@Yj<d;W#m7?R+w=dj5MAl(|(GTbSBeP*#znJC7^R-I-
zD3veP?3K_B1wJy!7g9G;*0Sl+_>>@X^MGY|*TVZin)oe`hQ=n^u%Uq(ct3@-SMkj3
zUqORT3En`$Z(=E&B}R?muag}#Y5(vrAJr&8$Ck6a03%C8n$OobJYaF~G?Vm8e`z#v
zxXRi}>NK>A{8F7qkcRU}OP+Q8x8<Qwy;GH3?G_WLo~Z$TUf~j3EWWrG7eL|e4+!&I
zblp2wP`^6vs$+_=u1f{=?T+p|KJ@E>Y3F!c|6Wz*3CZYU5*_aO0|rQ!qs)9V8H0u@
z?m#N}sKCK^cfgRK&U~RU-jZZ!E&JD}yKFau`{*$B4TP>;%Bd&gunz#6|8OV{bbZ-(
zT$s2|`$gBkC;QF?6PBqGATA<k87eFCC=(rc9n4>nL_Vo(l+VU(R9D%VdQ^3_pfDw!
zRQKv`EKrshGMVlAsOeB<G?B$l@eyUn_VC6_+0+@8gWRD<9GD9XAo#ddVgn6m;(UwP
zr@nAoGy@yvLkVrE5SqgVv~UB%2eX=aKS@haM*IdTr^Pz#H^pnEZ9KXN2Nj;_()ta3
z#O=-Q-+l*uigwv`$58JJ|9+WAM;pU@Qew+mon%!ucwx4K+N-@3HHFDe5mW%Gs&6&z
zaK{9y8PvsaHLq!;*A95jq|<P!qW2;FX!P~tXyr3YY04$<P_Iw-r7<^+S9BQ9xpf*X
zyn9ZV&zEq^!cAMgc&Np1-6?dgeuzLc!_5atZAEU{=TFV604D0ut&;Be+GwilDz}nV
z>ze5o4=$o7Ut2{z7?y+kyWk*y;_f}^oX-rPZk;Nqi66xuerW~W_P2#b^=J0(MW;^c
zPu+Ncf~TX~?^{TZytslsHNK9%amo-w<DTw*XbJuG>18e`npT^&ETY)FIb{c-rn|H6
zKf8P+)pfDH-|>&d^wevsse88y`o-m=BDi1uW0Apu|B&5!(Al3E$i9~w-yeBtCEa%a
zLQ_9S?$wLFJgHykJIdst!1t@Zl<WH)4=tv@{LAs(saWH#=QFZ0dsE1uLHu?_-LdmU
z)Ty!>MM6t9t)@TD`xpIZ)rY2h_Ug4AePPgk)TgG7JET^+ZPq{N`4y85ZQtrTI<9^%
z+PBv@dUMSTx^C)U4ct9Vs2fS&+U7WVe90U1^VyHnj<v(+>TOSONlg0onUBzu%ihj`
z1E97d#$XA9Is713Az!={IVi1Q76AY!?6$`)blO=b)7x*nOLyLOw}avG(uNX&N+$Bg
zOANjvK^VZmG*cdClxnqM1_s}qKv45hfBbO@1FOL6v^cm>g;h#97)VIQP;Q~q@9(&W
z?)~Ha^sQ^ZMx8r%%4@}zw>Ynf2?W_J2bET2f}jouKk~ri1?kx4mYt}aZ>sN{@G@<h
zyOFx@-Yeu!!-1%RpXx?_ds~?U4!Bl5zntDa_N7opuY>#1;Il{4@<$hkFq@Eam1iFd
zji$1deUxYG$+_0MX|*s87T!&jC?N)~wzo$MsCV3RUY)Xz{`BNhTDzfzuHsJq!ei^{
zpKq+@b=Cm)RDk17@WNvRhbNnJj~YPl&D==e{mmTu+`hf(w8Q$-eNQi^<*S=`fH9Ds
zdvgu_f;-XkjvGkl9nE=``TFGbbnZ>lLbvwbv5vktu^&D2`l^U$@FlK1aC0|sKB>QM
z{P=@U$ZLZUX;E1^aN}iUdi}%o^p}4wGroWQ<iW<yr{7p(d<X8&|6EFIxLm$@@({Y<
z=z0PUPj_E|@3S_D@B4`F|Hp%YrR@9JJh=MzTdV1(?E6=_EYJVkK;~OTuS{M?XZ~PX
zXxTnIsQME7{xp}18@#^3I0~P6>6?95>!Ut_|4H_}knqddkJ5W<=J5W=RyuL;0d&^z
zN%Wt$rWk!^4xPvy{F`*|f*0w8!Jne@haW+&t(s1oTAJwk?M|juP3vi8(>m_pF;^4~
zHM}wM!jVUq0f=HgST~=(^7b!G7WK7D-3U5+_#yP_>gh_78pCURejED}@Cj`E%BLG1
z`NvakHkwAc@rSK=iz53boiGS$I@QpLr+l7T(a|DkLy}zL+1O&p?bmG+iA#)t^%y{4
zxhV`tqJfx*t@Fx8ktjEOn}Vk=%q*eVoQb^@*k7SUBBuT4&mMO;{qU#P(!QVG+X$;4
zJkaDXx>9}s<-AMIq#yt42J`zJh|jt3bT+(<Hf?I4RV!EXjzln`F#rHS07*naR8krF
zxR&(o*GFXFN3S@1@swlf2drcK&O4a=wmXca>u&ir;kO}f{^bpH+=-tv@c-shQ12b;
z;=}hpmRWu!PeFIxww7jI^8sy~xq(_YwbIIe%TrPsP8E!}YFk?W{#t5W&KsM8(Av;y
zWI-N|p8NEnjkDHM<KhM-abo#=j0K>C{KI1ZXHvLH=n*)b+;#->=>3oDeI;)(Enm}2
z*Z+PV&05qzNMk_Jsk)p-59(y{-)G!x#;sh_Liaqi%;2^i)R}6l%Bc(g6!JUM)>9jA
zihuRJwMN&70X4MiHr=SIqKy9V*b>^n?da}*EHRxR1`Ul(tu$|OBh3wt-FK*^c}p5-
z*=qCKj}d#-ZQSNt*)>ez;wIX}N23=51_>BE;|`>}h!He)(<|8DoBlZ8_=hwG6!3i%
z`;PpLf0S}T`W_xoXt~r>l^NgPoVt!0`8Tv*<aUoR%<=th_I(}u{%f9XzyJU<F%9hd
z9B%u1?8&~*S=wL*AK*vrNev<=X>^ymF9cKS7-Z-XagyOrKEMMBII7NS3}IdX>ZO&F
zX-&%pTGPCVURgPfx>VLskIHT|w%Z^xQ}NK^S7~EQ1Kq#iC9`>NeBE#(<?0XrM3=pH
z7tP+d#N=I@0XS*!e)RU*Sv0?4xxwSq#EoQe!>aJuwZ|xWf9+f|API@`Ca~1S?!_!|
zJpA{RfdtDndnL@mk5zK=DaX_7S#xRanss53S!}c}TsYFc&py6nc~lg9=D!vmKA?@~
z3?iT`po3x9Y?%|VJOw$1j%D!RshRgxG&eQz+aLUC?i_}80;ck>nswqCh21|n!ASbV
z?mL_Oyg3U@e#GeEG-u{Kdg-}WcvD9s4+gfUz4zNARcjT$?+Tecd-pIE(7k7OlkeQ6
z6V=vrqjPz1QrEqXW=)^Xjii;ZOme^>`=-j=GRT+;N-?A`>J&jmq6*n;*<}Q;g>vY3
z%wXF6<pXHK6MNHu6NeaB8V&@tJJnII1N+jnZ@q8m<4$HUvV9#bzGq&DM)_cLFMj|F
zWHVl-p)DPqNNNjl@HkkKeYvz{=2t<J=#$`(gL>F!e0P45Y@^u=HiaFS*{i_#eYrCP
zZVuxbdA#`i+iU2AgZt3gNA;(x&ltut5zX`lKgF+JD-RR3ysUwMJqQT>c+Y?a+|RIl
zFnVxjdhodwd~?L!1Q`tAW~m1T2<G5BU=uU(n8gefuw3E~7$8&khag>O*lS#^@o(mW
z+$GshjT7HzFs`Aojh<!SPdvD<nVI<B=|jyx=+zI`(aN>3kbMq($Nmz80gms;V@YW&
z`~JYQ%fnU=IO+j6b=~)XSn9@J9iWQ~2e}(fwEz%12RagzogTY&A4@0mY{a=E4x`t3
z#$iR{T3X*M{&%gYF>1P2$_#U#s#=qux6uv|0DyQ6!@KmOgZu7Ccg#ud*t_w*j8E`D
z;t^i<NDGeHhD_SJ%uL|v+Etvi+0rnwAajo~PwFCN)aVg3Vb`7Lu3!IwNyG!!54B6E
zHRs0muH`~YmJXb6<56R4Fn~5o8Lrd5GB#E=mwHwsi?xg(7}0#ftRnVJwDM+(k`E+4
zcz3cHtqdDE)TrHY7nwD9@!9{F{LR<jPBW&@qU!2uTDw|C;v>0IiVb`1w<nLF%4y+(
z#q<bI&Hd}i=ZvUN?z4NbB1_6=i$5wh2_B{LbH#D_QnKa?*=$+WTW<1Q#&)C07raTU
zcs63#C1VH!fHYhgKY3yw#3CLb#LYCoV;uD-@t}ko?Xm}D9a&1kEe|)H)x)iy4qo}5
zMf1^Idpr_JZDD8XOGaJ~tQzA$N2O1^6GnBViF@><JN~|y%31^tJm_{B*^Lh7JrQ>@
z4wH_M^Wr;e_$j@DCh?vC3=;koEKf|Ezlk<Bw$k~>52QV~bH3<{^~SB*uDoA@Z-hEE
z`<eZEnGWsI|E!e30#l(I)<Fbfr3Ih;(_6n08#ztn4Tr^q@$CB{>>u_>@Pk?;>=@v%
zM?!JWzbn2U{>fg{zh^Z)_4-P~qrP8!Ts>i6a`_hq8F(H0?uKLb72ltDMV53>p3wn>
z<h8zB-lQ~swmT`H^T1#Yt|1QkDH`8>IDM-3_GUKXKPx_D3=swjt9j|-<iVe&akWF~
zw4nzXxDF^xCgy~VrI(C6lK!&b`Pi8T)p=m=ac0@$<&{%nq~wB71{$QCxJ~i{r#qMk
zH(RO_Hx8IF<&OhT>}Q>O3O)Vgv$S%#)SHliDL1(KU2GEEr71ei!ZC=zpI!s`W%1y~
z87x_P7RGfGXRj7h$p;dxe6z=It)p`vHD&}2sP9jkHg2N%a~Du2UQ@dA>Wj^r854Hj
ziTVxbYi#Y@rL(o!OT`)QlJx5@G6u4quUvcv9dh`m4Z5~YM!zoYR-J~U`JCN~9cWr5
zPf`o+oJFf&SV1$d=Zl=%Lf<0?QW|am4-l&OM!KFmm7e?cp^DDsRKruewL5l?6i46B
z)zhjMmQ!m3n(jxuurk(TA<ZF;Hm<ai=>6LT=ybrKg9h_P1lK_|A4p>$F}!~bU3<<j
zdV!y`|Nie45f6v-ucm9x87jDE1=pE38D4hcVBQn4jE=tI1N!DKX3;SR^r2n1mzk~W
ze>2Zaqkf(DTwr-)6Avtw@cw~DmW*Wy9Ea}Ni(dI~Ep6m=TYsPsF`$DpL)pJ;&l*b4
za~pnu{d3E97?;a+XAPt07<Yf*dl&Zo$}bKk?1?zy%J=CC_Wkn*^rbzvlY7=Rch6<-
zh_3q5(9ri~ygZ`yi1;w}{Z;n8iI+ySUQiFXp}YFq<2r26!Gm^2+Ht7dU-L%Dv);U&
zem>)2I%nizgpHI4Kb-bA_MwfwG4^=cz{?x!nl{D`4pa`}{d<q60X4m7#`+~RzHS&{
zMx$R%4;t24?(s@{c>i7LUn}0_876PUrUXH(<>i4*7Q?bKeDx9~4W|$^mR!!+%pq_`
zd(a{KQ*CWGnm%nN?X=4{s;;S_UOZbqY}BwE9tFhLNjy|}+7s&l0)uJeV+LWEbckKn
zFuaUR7)$_NnL&QRBriYzDvjN4G#&fJqs)NfowsDl`oKy1oBV=#3+ek;-%OwT{E>9P
z!TUtyW8DRzSD&7=agI!pH8)EqRb4Gly}f$(40%?qkP-RZ+4Je4zdaJdH*LZ#XY+=l
zn}y4Ww9}xyY{a27T!gU5Od*>s8y8AlwXB!=YvWz`nEI;V9r<avvP%AJEU*2J{LXg9
z%5q*e?=q&6hF-*Lpr^^yW$ms#sIsn_7X4vfk)C|C*xcseTkhigP9L-`-p?ns7ncX=
z$9b(B0|fbll=RStUt#>=MI&hnU$5W)ZM2Sj9Hz!$<oHotj8JS8#O?g`sq4+Mz|Pxr
zrDxw;LoZH|14MXr^p96<Lo*g_3U7)#@l!tD==ke1&f5w`V$#X=GN94x%t1Ytcf(<{
z)cde)Kl<uO`jCCU{&$}5jJr9&UH7}Wrf#5e$C2{7<kPROHn6vNp9q$Gc4gmR;{6h@
z@#a+=2=M*)-x^D^7TSG5>iYxFEH{HV$9%(6>`6CU!bS`rFgSCA=m9KO<14GD(K(FS
zzHTTzv+P}(vTgxgKlNV2j@LtfvGaMfVABduqAQ)KOL;YIYHgxRM;&DlU4uOrC)9t6
zZkYZzqjhAL0o0e@1bJ-wn^ESNT)d^0u!0HjMnW4u^gfbjkA!mJiM>mgE<CH&LZ_a2
zq5)S`Rnefq_4HZp&u+c$b|uY;-BQz%RhZ^;m|Q>-kqQZDQEz65#4{491@6k`G+H($
z0Ad5{C}Uh(%pOM2cgR5E^;h1c6Hhyyh7KQMY{GsBgyl=+X{2knuDmZ|PuhFmJq+AE
zfu?(pI{L~*XV7~*0D1e3_vrn1WVr<UAkMz<G{Oc>4R5^q7EL_zAR07eAnm@_ZnSjC
zGTMIpwzPQRVxAe9u4G$xj0S>=;wY)DSO>CES^CYB!dn_mD;uf)%fo2(e^yZMiT%xM
zLQ5W4NR8Y9xVSz6ZfSs<cl(Uc$ekbEn>Ssqp{e}(r-U-9KXoXztZSk*Jca#H52(E@
z8C1W-(kUuT?ZT}Dvk+NASAM#_^^y^MV{M~fKd_ia)XRGK!exzSli-g7+%F$kL__Lj
z&3r!NUY@evEK3}JP#?Pa{}#}J6T0(;yfX9JD6WCsdE@Ssc^j#k2b$NOIm|3|yc}#w
zgk2}_tHJ9wwa^<p07(w%K7?4k=t6*8i^*~Y1K)q5zVnjJh=GCcykQtmceh<K(v-_D
z`IT42EnpmM=5Ygkk$u1A-UamOU3wVb|H-e7BJ93xH}-uK)v)j1J!7cx{gn^an%M@_
z3uZ6Y^DNCf(>7$RC9yZ{j3U4xPq0FXyi+6wulYfpd()V%1L?Ju)2X_=l8zfBo9pLn
zSZbKJ?KYU^Y+6Ru{0)W+_zes!b$qZ^23pwTfbUOq<{1Zk-Lbw?FIwHaf&Q`NRr)(0
z8g3bP8ck*%y#A@-i2k3T<&A4-+Im^yRJd<zXe<yh!T7-^^Yi5iG%;*k9%c0R`=6lu
z?|X;~Oc-zY(bY6-=3M&qPwwK`p@fdu6Q<>;U^gFYPApKlCC1Ey4k8RB15ZQ(H(D$&
zB?c^el<|XNjNA?xNHp>;&iQi}(vV?;cxPubefa)VW7{h)y-o)oc7R##`25L7(;D6*
zQC%bNA*=C!{@q{c3tv8thVveaz4!kl8(v25z5M}UmIM19@TSK4b?XU(5j^o?6X$*R
zJV>8C{s_WyiH3LHd{2`fiCC)-aZEjJ5g)KeqL4Q?rd{zKZF~DpG~v-tQ5(-PEdKLc
zYT`ize9Fb~o(SH}FG0QLIJh|V7FJ$UZeAl@{Fms{-WDm4B9+3sQUoi<rjq1>La5>g
z3rT!{W7FLee6!3FhH~dw8+=3JhZl|rS@5>Tl2uLN_a$z=aAb(P?)P))={Hx?Z}>Id
z6F%LC?*HC)=860ne&zA~*)p?*PIiak^5njup@lB{+03wM)bJZ06L>Gq1N?e$e8^Tl
zIlO$~VUGmfS}`Gym|+7th2M$z(FNA`8~-q0d=I`aamxkP_ZxUt4Zi>OvBh*eFXh~K
zjrfk&JwM=C4XFGAZ#>?9xXjqV_pkqaw)uz=aPWQSv0dpQUgm30(0dGGbUujjK`MV1
z67Xm-NUjsl9-K975><?lj&oVV8v5Owf6~ki@@n?s{dc3?dW|tAu54UK-<|yDKnu~4
z19qdM2lBl=2tOHrCch^70{v<JvkH<}jSQew{0iniy|$-6FL*8oAGI-H@c09$jTjH>
z%Xn0G=#d9fzBf0NQ8py<FN2z;70kRUrZjP^F95QhBvq(EU4AOo3NwaC97wPMC@kLl
z6!%39{;iE2lWYs^DfMq{;7tnzyf&jDw(t}g#Mt-H(9l4Q{I-W5P`Q2j^)^#8nAOnb
z5TC9i^Km{zVK!$|+>nvcS_smbRePg(o3kmUEM5E)ex3G$Q!g!8VCP|7sDYoT+Vs<C
zMuK?U$>26Jt|Kik*yNHhxOG|*fu0a6Uj_$21Ez<~TfD*$Ck4MIZn*14y5iKYMaY##
zx*Tb)fLXYkR%k>-ZYFT3zE3qR<R^9ihCGPj&D>5FuWZWYO@-K!iX%(H0)F$IH_^qX
zT^@FxhL%s3Ct9{~@)ahf;GPv@%W5F|xXAHc^$cb>W|5Z$zAM~HC@uwS>>;%&783pF
zj+^L`(=X2v?CO@ZoGbXo)stWM1pkVrwN4p{jy}9!qJ=x#l{_1vIw0I_Lz2fiPjCgK
zkh-?|WN|pa@Z$In@4S(|de+xX+UJYQxAI#bt^6Atc$h^%tH2(WYVK`)JsC}xLK9&|
zrk+CnFrgS81hO)ng+Sb%fL{ac)TvWsdE<tgucj+5zS@fApCp&pXDtY+4w;dNs>sc`
z0|;RKg3sj;$l5jXmPZ^O6}ohB*7edj37Zd=>Mz;?2vXaGC9tW|+wVV}_!?9<VjK9I
zAi-0mb;MF`n!Ul2euPp{A2*-ju3qiJ0Mi4vttd@lw#79w^F09;0~~JpSTC2f$X2-I
zia5IlGy4Kw>aYPwu?kBdn>##)Zz=de%n6{JNqlPa8B_9*$*y7v2p-!*HcT#B))c~0
zq~t|KOlN9zHd>!PbN>AyQZuj>0Uy>{&I5?J02(YosD9-M+>Wp)&H$Ampm1@Lwh)_&
zhzm1?;L+wQd1j(1?i&iBM4Kq*Y5rDxI$LKY*i)E}!9+g2{(#v^4N_hi<lq?q67y;&
zrwZ9n87E6&GSi~Dgcv`3#`{YAS&1z&kZ?`RSLiP7e{I@tIGjhh_+aaQGRD%hKb2)!
z!`7coMJ-pj#_hMOBP481*15LmKmjluxz9VcG+aIlO-{M3NIDm}89vNY`@jj_Jwq0>
zxSW7Fp->|nR!OGF&Y=Y$o5E~VMEI&_Dy=(+2uuY%f9okV7#gKuJ|#ztu18`{7vjDO
zQMpd+ia}Zj5DrOB@-g;3Ur?1vG58giC@WuKB{D`4@XOZ~2a9sW=P;1aMfRqo4Tl~p
zeuJZxzv`*861axqLf(Nx98(?`uG9uTn#`~;4{=5`1`@d?>M=8o*>uSt^>S|mvcToh
zZjNjQlQ)MMCDY+IXb6tNqB&I@4^^y<qjb@nr7CR-OB;TGW<4y<w?`>_xaHWKDc72$
z^yak3*9Ds}K+xCt@WuqDNNf1e*DHZb8$|dr{XA~4df<kK^;8^qn!yK~B##b<r?~IB
zi6I)?I&{;(`+4O_i@~Eu8l8_*9zXW!ipxVP0+u$?g5S{_K0YbGQ*Z%{F<S6}VBD{9
z<264f#+_<8<8k=1)9f%fmFvcgFj+pizc7l;ovv*v8+Jo44lHdLyBMan;R!ozmuxG3
z1Pxz@#OsqdK##-731W_-L3L{!#TK1|PB%cj4|DNp>F@K>20|4-ZC7UO`7tZOy()8w
zR_NCO8?GaBFi_nNVTxmn(ChUVjd5+p9gSRBn|J_I%0UF1#1m~iNHBv5<Wd69O33#n
zEX@{~ktnvZt=az@DU=f$VZM-+E}xtvd~$syW0GWbG<@r`NIX`%<k>Us=Bt?EOUQ34
znwNP7k!xYme6m*Ifc>tVL~d1(BrsENsil=9Bs)Bdq%1U|F`)E)L|%m;cJas?m<$*+
z3wcPFGC(c*Kvi#bi6(PaWT4o$0Rsp(BvzLz2Q0{I><TDxTGgtRzFNiSQyWKzjvk?c
zpSD}Mvuw@KsYYid<ohNVS`-`N>~dx4S1K_8DQVyW)iTX1*NlYuv4$I)&c<x^fkb9w
z^Lq1NNT7w2sf`pwTy$ZnmRteJm|WV@Lbjad{C=oyIxIlmJs<%%rOPidnL?Y1-@z+9
znR5$bvKVK2ui{FmP_8ukG+a&zvR|P0-GeJ`eHSD%M@fDF<Xas!rJT7C#YmhFAEgd*
z>a@nOMEQYn>^>|v??ZCyz}1{fZOaR@atIiVmE-p~crekHXD}g8@pyv+SD{>qaXMTZ
zib+GJ4kG;Py%>49JY4g6e2wt%OiUT3(ai6bY{t!&MK#cf<sWBIhDnVy4OeK%CD)Z|
zNv0@Nmrvhul6_6Z=Y1P>SfFs7?3BD>i_>T8J9?8+xW<sK`u%j8X7IQ&a%uBZ<np9J
z)XEgCic-=9ae2@QT!n)R(c{u0?dA*DTo}jZ)K!>eQEIJTKs9Y+O~v7&a$NpgOftkT
zC)KDiIPtWN!9)u-7p8QuW{`+Zm1!`Tz)XQVa7?x$8wNI+0SX(9AKh|o%qAfl6<o};
ztfAt-z<Wt#R)Uv<6yA}sUvV9&YwMMbCJ-%&XfEDz&?GmWWK6uYbZELgiq$w>R#t3j
zrDf9!omz6m=ocQ@U5~UJ?He$-mgB~OX;#>%2k>z=$Jrl&MKX>M2rMwDD77OyJ2;gK
zG4d`9lH5Gf90JlHC$JKpeYt+V7*&u_3OU8-Rvs;3%@-1DEx9~}`s2!oO9Q4))sl9#
z*_IN8mM#aKS$rzzfk7GXnP{%iM}v49%w7rpC|3*rM7ry5Jau7Eb1&d&EuAeXj5|AZ
zQG*{0CMtNp1ea5X4<xcwSax?m`jm;~;UbXE)FPEhh%>V}#i$Y-P|1^<Lr0v^X?oLe
zzAPShn;Q>!a3EibfLb$88zz>`SyGd6l`lFoYjz1^!~yMtU6`A;oxDJCMi73bRH)!`
z&x!|ERI_6A_6}?ai)3=8777XF=3$JdiyEUeew;^iNzhSCq9WBE7wXa@ji7Xz2P{h(
zbZ$^NF3e9`xjKZ1>hkHgmV6n1FQSrPP{=o!Fk7K{W&%G1hVqEpClOapaWM70nUNSk
zblg0IY6@Zu3<?TNkAEIabm%~$P_qj1VJjkz^D`Hg3yHX3uQYpw2L#}B(Gfl`qgvAF
zmBwRrvMz<2c1SWLi|0%i-f?pM0RyU{{o151<Ob@_G-$1+)s-}cbPAMKj+OaY(hE5U
zs~R+Rby`>sTLb{3K&x>C8D<K;pM{*siF_8ic%(J&KB>9zWKA7|aZAii``UnWgPWJO
zClG~etUP#2AT4OQfJV~zqJXB;I28x3sE%BS(v~(>+ck!CH?5t&d(9g>mO1$2dU!1~
zY0m_f1<H9=qP3+lc&o*gT$mpyohI{E#@0NDP@mXOE|-elb^WhaP*QyOXD5<-pwKS5
z;#{+)GIjEFgVX%jZAV9NhcWMkOpA4<F^tnR`2HJkD3`AWWdZ**J&pZ4G{A}PqZs!U
zBuQ|G(D|H4OCG)LD3b<mI`d8XY&;HphcWJgfNu=*K_-Oe>a(_JS*vYoXB;1B4rLuU
z5HxM_Y@g_}K4@NTQUBCV<bi|Dii0f8XT_mhl+P_Qq~Uv9nWf>-hG$Hk!7?Y(d2AcL
z(g$14z2Y2`p2@gF*v_*#54%S(PSfB!__GIxc^5a`!C?dZ2<H0=%fJrsDQxFNmU$lM
zv-==*JBjT)-`G-S+6!dB2b2qB!fxczmY@$t0|y_F2M%_+IF}Fn$fFz)5bFV1(2dxZ
zwdAGkX2ppQkdujz3kkoMGl@UdZuE0L<jaGb&V2a9yD77P&y*RbfrCusF}s9#BIj`+
zAU-5G(7Bj;=XfUnsxdwveiq7t!$>YqP0#3H95<zizUhHJ*oKY=?M%~C*}sF?{&N_I
z!2|3>y@L)o_=oyNBaHLimWAL!hcZ(>bhKeRV=1s@B9{yF!A`U@O#^ob<4n5?aHg#?
zCF&M3wO$|-Y3TFo9oMGTrC+y-LtV~bnW%TjL4Ir?6R)t&;%gIa8v21VZJudi1A^8$
z>_xq+52$zeci!b^F&E#@wi!uZz3fbro;qbF9mb#6HhFH>=>LqJOqh0`@NuXk)E|U?
z@ZmILi|JEYA7oy9#d${G6!!0kqb7#=lHoo(iO#=>ePaD*pZ8@tc+&pnVD<FmWB)>w
z61YWl#3!;**#8S5&Ce*#<}{_TmXn{yMehbT@1`wHJk;XjQmWPERT$B&cm06Adg^6y
zj1idSh=5Zw#qgvGOhAerdB#9m50C>|tQ}HfGRvT)hgc8DM^15)chAtAj1^0j9(1|3
zy0&XtW5dar=<9p@^ay~XR+Aco58siv_*D5+vI{pdOL>YI+djd*D9y*mwk#D7?MUN$
z0#}|E{XBU4EX&WWWvsDsXzOv|Nonx7IF(UIte*#u<MGQ0Gy-$aahy?@Yoq!XrLZ|y
zC!jWO>rbhp?OdVpF*-}0WH3R~_$<6%@2;&NM!ty|n(@IZFvbLYI=hm;ZC>RwGi?mW
zNHB1SW0`F%x`Fxgl}(K5c7ZA?E2uL*kIl;zZpisWwu^MqC12WzFJ4FE$I1L9z=eo%
zGz~0hePN#AZrTcqhg!U!0zCp0XxacWpR#ggrOT{1hA^r_ZZv@5z|#d%Q5plxe3ELA
z%NuDt=^+HwlW^hZ)9B+>n#i{2B5jWmSH{yMaW^Sg5<_mvEDmmMD<b8)ohCw+Gml}@
ze86L1fjmTdxb+>N+g1N*CKiKJHxQ#fB({<iZy`37hO<=pQz}QxCqG9}2TUkD?pe6=
z$x?hSXH>h=xlrx=U07OL{qt#DIp#VJl<`&wa}gLm0}CW@q_P06;0>5934;mq>1=*2
zvI(D&Rwmy7KhHw(wa7C5K{gCT_}?n@X*(<rBZ?PZ@_|J0ru^@6CJb(EfuMpjHOj1n
zZi{i#R%KEuD|J@7Bt2<xUpBf~!0b_E$LlCXaqA7<y{@$r_HAg_RT%2cl^UYFgiGnB
zU9$F<f=Gk>OwG?#o|blnxyCzi7pylpz}y2WOx-(t1{PrkWa|nr7Y8=cX*!FAo|{=%
za%hT?p~b0XFQsl<yoKkeD;S{mxt+Z$B*dGNvx8!VgVs%lc^Ih(bqGi&m^UMoPH7#y
zNwQ(kTERDkq`^cRzIJJ5{*r_^LRnvVWjU4e4`%UicvDj&hBF!X91*2RN|7WKOa=ud
z9Y_>!Mg~i_B9dbL%;C!cM4bfMG^v8xl?qK_QhZcbzFZcrEHwG_#Nl1JrsH5Dz;Ix#
zv%NtF3@9;o&|u}-vb5T43UoGSX>rRbHh@zl6(=R&@|jtvFI)Ab*{Wi)(5A`B!36?U
zz8fQL4xU9(cn*II!0m)ENLQOxhM$iS(IFt{Mf-Ah;j1la3bW9p@w+%JgCrPc??5AT
zQtmeIa<wn5KIOz*c`nRN=W0}JE=D274{=7FQk0DYF=#hRYLPK1(DAeZe}*ddI}_NC
zB!h{T^jQg3R$f(M1`%aEh`^7a>6ap7w00~gljF%Ilx!f;PCJq<+zK%8O`B{MKch6!
zT*Ms+b<vtvWdT~VAdO2$WQG}+T7j-Ih2@X)apl9uX~@qLy@`Qd2N7}dvcRP5<VF=Y
zV9>J7m6hMxXw8TOpG!3R&}41-DWkkDJ)W8(jZ3p2GM_=t_12&Qk#5@6;_3k0m7+Ko
z1{#GUtpTv;Ayjd+%2Q124l2|x9b9N0a!ak(wbdOws7{Sty0~;!I-l3|2WibqoI5a6
zJbqil4bhy7Nl&|WYdSu*0|!VnO%t&a!vIZ#AWsNqcU>Mgorgak+7*TGCsgo$h8FBA
z2o;M2Y_6`r%!FB|5EyvF^5lU-MKzZ;&qiS2p%kIt0c7(<YC~}vOEQpXp9#eozPY&6
zH;qf7*Oe8f-Bt#m+hP-x<|k9>uJ8n531F2Fhfc$}^!e$cg9h+|NBDAYdamrGv=pD*
zq>$F)^y4J{!r@uHEL^hB;c9ZzKAkB*b=X6qRHL_WkASm~oxmOv$LUv?8zXJ=lG1!A
ztOFD3N7QHes8~m+g+4iK8&o}Ni{|5EpC+!X6c&vor!dHN)2=SSeLad-xF0Ltjg#an
zjmkh?(-Pa-h{6NTe1aJtk~jj;F-zZ!R*pXj&}ROe-dfoLlENY|^AZLI6Ro_*p$+>c
zf&d!;tAH*(RF7f7Afko`5&WSmJBVOLAPv1r*?h5<QL!3JGLR@%`PR(W-hvh1GD^`_
zrUl~VAw@xMTFLXr8SMxJ<)hArhnQp<dtrmdJ&;T03yjMX$*m%|CYe^tEf3pA2A#cp
zn9_IN&j(&ZrlNfLE-tQ+TzX9-)}s`48mHHXsr`WKZCha`hCxVhY;5B+;xITF+{?p<
z#E>9c0xEFm@&(dv@bfNC)5bo{aIB`;SW_0~kf$bH{g^4ypk>x<oM#_EXw@j0i3M!0
z)i_dRb@jPIfS0Ae1PT@4GC66~k6K`2lLvt?0;Vac5n#~Kv!~qon?K`ZRDYZ=j@q20
z*$TnZ%6W68nR((tf@(%1YDK=q(ZNQwRk9`gmPB0ms4i`^`}I$$thgfiXu{g-Pn17C
z=R(a5%V}p)YM_V$-JF{Sy`L8u#hqQ-d<khd(8lA#%gW$EBZr0idWy|UIoQ&$DJwA!
z25cNW4rV1~PnAMWT-my?Xxh!i*a<WnC3d-Iq0M41MA$?0$vH+}i9xVWJ3dK^f*iZm
zpa6ku&HQ9{QcGpL>046lHP>ql9x7zHOf8EcN&vx3y&BYHkZM|EWjF5N1VrGQ;!MnN
z1tXSjQz%?GAet9!F2MEIwZpeJii0$TNO=go&VmU{bh~M>BF82HM~p3J!+49L`7=-T
zTyfyTIsEem3a|mR0hjsh3iFnP;k4q_a#gEwl3gL388Hjd8vOPK_%JZQj0GANesl}3
zcUD$cQB`H`GkgmVMmBEPsOmOrT*Wrk)YR~|rR=N<49NQWXOwHRn!a@@L*q$mK&7xW
zPPT!Ctx)u%q2uD!3r}^s{BBzD?TsPRmuo&k6~KL*t1p+=T(Z0wsmy#j73;25Ce2fN
z9AkrInmku_A!)HgbmI&?{sH}Q2W<2Y*qrb1d2C*O5f9HDxMd_Az~?(~k!l$ut%t(2
zEY*J|F~Q{dWZF{@8${6NfY;!r^`lh40S<lQhm=uVUAp|>Yj1#wc&f*N-Sqh4B7Vt0
z5A1EnA)UAF1R{DNgb&ze?B@k|w1=dCeg_{Kiwh`21km8nbStM@7=R~v*(?VlIq<ZK
z!wg<nH-4fUM`dtm+d`YsHel*H;8QuO(~Zs3F9Wn}O!=^~MjXtj2g<9N&C#+leAYxx
z*?^C9nc{)3e5lV#0k>?3<`gd1UC_m2j{pm@e_RjfWX+$b(zEiL7^1zy`0fxv1_JL;
z;8!i1sIjeyn)qmLYv%gkr3So4Y5rVMs3U%LlkuRdDC3Qed?4UsY#QP`i-Una0_P0A
zfQi>bwUOX{-pWfDEnF|nXsw*D@H*>I4xIdm2Gn#>A!utw@%HT1gKoR)hxFZ>zLkl;
zl1Fa`@|U)D-E%@-`XR#y8`{A`>+{l<nn0R%y3`~ZxiA=uwiL7{pVrT-rX;xH(_-)@
z@#Dslgo8}wh3&XKpo7NEu{wz31`XBqHM};MYf)w2YN{I0DHpMoLu?ti<$<*P`2!h0
zA2+D+VRmpLW$fcMFS6~x1Q)k-Vm5X=EZ~(FvFgE>{i2<m)UWzlOqKNORmD#`xvi;J
zT_yGHQDvIEJ7_=$>2`Y1srucURzzYXBlPeWexYo#1bn$NF8KF&3?N{iT&lMHYZ)Te
zvK`Q?nkvndx7Y;v=%iiW^|CiI8P^&dI#AF76b1-paDa}9X<9(X@^qk}a-hQvOlAUN
zJpxb|O$vNZ!iR(=p%Nia?f~2^o0JRy*(xryp4HvBvj!ezB^^1wwa}xo8}+K{7Dy5a
zrZA;IBdT1GrdxsmfesjyLH+k*;FT9?3?jhW%7Y37e7VvMF0GqRqH*EG0|_$=fdK^q
z`->$GR63sc%?yfQoHLh>-^d*7)}G9rU&&yxZ9*A{<4AB7alqHK{BZIaU!Wnw2GMOl
z_yw(5z1E;>I@QqUK7XXizxvYaK1(FO>mCz$Ah91k_K&A%-kb#yoSSL453Vpyms*}D
zJ|_!(ZUa~SE-Z)10Vur#%9~W4;Iil2hV>h;nqi%3;3cD|cCTKv@q@KA?MrWjGJAi%
zp8B6NoGR+7_|Dfx^S?ipR{V9L!H;`sAM-I5WLj1=(!yJ3(#i)G8C;Ugx=;6^VK?ny
zXx!7HTW8SHyXU6b;?n=Oq_u9c`s34QZ8vf92lcC_(?8RnKCx{rO`EroF1=-DNOt(%
zJ?W%F`%$;fxN#Hx{Jw?s$O|hC{=OTxqpAwAWbOK9`prX2=<%0VnRX4CXE-u131sdy
zzK*`}<-wtRP5kB`OX%LGmyyrs+M=}WiGy305dq5w@c{VrquBRtvibfnd}qe{Zm_<u
zVc+k3criT|_&%6ro^{j!+LdKa<?{UMk7pQtdylK5|M%q~Ip+WRAB*WP|5`@iJDd4-
zW4<X4pI_H1APz2FzEY&Oihk8~bnKwLY2V&E&|9l#(v4H^3mDsI@7~+d7Y6S~eQN3m
zQ}(ydc!-`~@qxkLxyuFAsj}Lnmuy;1zn%Luy|i+Q$@gWM#}D3{_Uk>4-dH_@uAA~#
z1K+W37=35E6HMAY{dC47^yJdF3AV)XxwP;X{#BG!avS5>93DiZd6<UlJD@Keb;6Of
z-S};2?yPxq^EE#SRY4Er^AB&B8Iy9>S7x4`crOJ8lx`zZE++q<8c4)7J}rx^@#>YU
z=-O}HM2!uNIV@wg8AZMN^rTMwxlSEO<Pa4JD246WRi|rnvC)e+ssT7@&~gT!q@)wq
zv~sz4h550o+s7fV_{Sc2++29bM~`@mNB@2TwXET(#dSQH8gvjwJ~I!zcoeOEd<iYM
zX*v!1<`^1u<rrG^=n`sO-$Dy+oJMP&S#AaxgRkC(>aQ40s~%cRZOv_zBy;WaD`?8G
zuNd(-bw9W-^*?*Kk%@c~A8;Rs+!8?jYFm2pfhTeaQXn^9Jd)OJXrT?8T6o&l65@V&
zI(KZ(y}5>d@wbI^-mwGeoTCTQGq0~^+E)4{!(M)OEe|lt=)w~Q(%GLINKd`Gihquo
z=oU{V>_d2c@;W+~+lz+1cdVlmC-q~Qt4tg9`IIhe?ECKD^YPFKnA(%$J0p|^zCX*p
z|BU^-An^UEH&)Sl_8qVn-&<pRzx0H9I`^{!>2da*`yToUUn^^!^3-~H<->J!#!Z3m
z4BVG}{}TKDG?ypB?G7KmRcL~HrHaisi$s+RLO>sX;K^|2M)}Mvf|>IGl^fdVx*blY
zRZZ(@Wz#yo-1)7AKrZGb&Kx$8o?7-6-8=6EI$_8@bl%9r>9y6<XcPa`_RnWNO7E_j
zV_x+<dC2~B?ubL_l~q%@W9K#babIG2D$_n_PF_2o&Uy0}p#i&eA3<l2IE4A88?DN>
z!q|c@JlHxCzmdlv0y5n}gjoGpfo=ZMZ(m3o)^DIq8#nPUX<IvCAav{O8rniDFS(SJ
z^ZXR+#uqG;!vD-bLMtSxAOQctPp_rdUVelAboad>+3tINf{s7wXu9m&Z_;H~T}T54
z_A|Ie3l`H4zIUrhe|qA6bQn*icj_$D+gE<)5}qMyrF;K)KfUwj`-TP^Lax5?8`P_J
zPkQyGH|V#&`lEp#^M#{mzk@zS%}vd;V7@%b8U&yA+IJ5+`h?HW2k(AJqsES)y6$x}
zZ}xn;;p!jJS1vh|#%?#7uyoSg+)R_-okG97^-j9+_U{=V?s0tBE%4!T_Q4Oi<r0NN
zb3S+eJowQ#vxYSKBwG}YSdKD!;{GRiid!zgEV^f$`4(;D8~y0t?h+YDbo*paGvl!M
z=d-9~Z8I(8C#>!V_oMCy^`R9HET-lBl&WF%lS`@gQ@yFGe+@Ox-$Y3=+ZtM_Vde&9
zqq=>1Q^Twc)U>$4z>@evhL018C4hP_Bz*n0Su~yN>W3GNhzukqY}3`uIQ*UmjO#bH
z5@rqd*||II#U0?2|5-(kzPKt>^E`LByKPrXeY#iE;uVdQB(tHZmF6zC4<NhmP)l={
zG|;luJb2}h#1|^clkk0yTz5eRorA)!WZ$Q;?>7g&n_ti53+NNubThu+{pey^v$2JK
z#j^(c2EISezCZMm%*w!=f3xqq^K4E(_I)Aye%b9ajm%pw9BIl^uTA(qCurZ`+mn5t
z!@e(F(}b+yo65F;&kiJT{Yocq79MyMgbqu(PxXSAzL@HX2cM!!)6v>Zk=XwscLYmo
zoM)r1o_r6@-?*Hv7;_Bs*$#4S?I1Jb@bIG7Xj5w=J+R<qn%I8=jjtO{udJL(FRYww
z?8WJomD6bdzT<eAqmGs}uAy&#a1YJhxQxC&_L!j47t%)F)3CU~wwGOdjH36~%ryfU
zP+axFpO|ksebeI;Zt+hB5$M=uIm6Z>(WCc2uB4gb+iv)|nTfdgstdw_gqBbX|8i$I
z*TFzj+B_XsS%H}eTTZSb@S37_fghoCyjL*}Xk(5+ML<{s8Z~w#|M&;5gZ1oA)iu>7
zuLFd|3zyK!6|2mEp(hUrG^|;*hL$W|Y6cI0EnmLU<kzlQrzF&w2N~E|ih#ih_-pIB
z(E*3-Yu27H7#KcsXh@Glm#$rmu3dK9iK?rs34@o~?zM(y#OUEPXXZS5`MFoj?8vyC
zx2L`K+r!B6eHhI?sSm0EWs<dAz!OKSBY%~d99wRiikGRnK<6K>e8u4=g7sWo7w6S%
zv#yLyciHVDGl+2IYr18H+~~}*1_R5x%ZgeB?}?DjU~SZ$pWX&vyDim!eGF~jC$$ap
zH=2ua-DG}Z4Q_joXD&Du9K@Bp{@!`}T3UY3ybyx{&Bvj*5=h!`m?RB@h`6w7t=zC{
zd07LYwu{95dt!Jh;gCIg(4{91qH~X}rzvwcnn46GNiqXA6ZPm;L1Tt=roTVCA_QmQ
z3yEVA5#RX&(HlILWw2q+Y?^c84;OGd<vi#Rw0*9^tQ-d{=^)evz7KGGpTxdj@x{UP
z)nf+IhwS?zzD{txO`k7=VZ-R0^m;|yqgy47W#8|Aj%V_MfI);CKqq$bn*(?n4h9j3
zk=H#9a*dbqK7oUn9#8Aou-MES644#91RXi4bCAokNb|Vk1{xuVOnP0jym`>20{7}N
z>QX5WhrO%hz6-nd=sA|YG~@uDsW_BgTRGhf2w>6tO)HF@Mo@49y&Jk!cBW7C97T^T
zej@~95a9;pK@9(}oPk(g(iBSd8#L|)V^>a6dLA!lxWN<+w*&nAcQ}ZM5MWt@ZBfHq
zT#&Y{C<fWlAh!aG(3N>0kyZAxrOVBX!Gzs*rtkge|CyPH`auK20mAQo{U`eA&A-kO
z_bSg~-1wbaXw?dtru)^ccbWWqZ_BzG7%)Tejf<|P58t0^__rUo4Q)SuJCg?8*UrDn
z3={y624qm?w2}uVS6pxvUHi=&>6)*9-@tx+{p~b!`YfvA0fsK4j2u0JTpz9pd>H8X
z0OpkTU}WnljxG+S^ht3VPa4jb2U-joa9LsCz%Trm&5_8PCl-!1ByBuXyt#NHw-Cid
zV|41R8=7g*Rb#1c|2{P2yW1LqiXJkcfSm68^rG(j_NMZh3R=Ol64<7MZU_f%$)byY
zeUDQ(++FFtP8x*A3|ji&BD1?6PldRcgWDi;Gn(`6fs0oDtZYO0@yYyDb}5Pho%+Vc
zR=VKx18L9kwRG_p>y6mju68PTSDuB~V_Yp&SCtWFB?<{g?bjRCPEYX@etUwpEwnkb
zd9)kz76f;ocpIZR7&rirL+M2)t`~dF2#kN)KJfiw-W#+R`+hkOmJsS3-!TjEN#lDt
zJ@?jHeyW$w4s_DVA>{_E=a~I^8Q(FxkshSoV_<;Ih1lo_*=?ML7R*549SeAM&}R-b
zxQK2z>x4*_Gm(5ihXKZFUY<B<$o@2r_cok5>_CI*77Qqm*|Ga@+NaO<Jjke_mwA5#
zW(lw<vx>_=><NU$L<ja6XZBryFG~=AU@ZKtG=mDnC<~MZ%E8}knMJNkgI7D7%pE4K
zM2rga%bM^pKJeXW3r<PkUf7->ck&boNp2^x%;jZ+`oROagO|<%GX!0`b)^;Dk+(Oj
zU$?;&_G+HJK)`Irh|zL$nl*j4X%g7@GN8VHj;iTXXY%?ZE*}1w)=dq(2cw3*cJ;+(
z_5m;qQV=?K>1>uhTpxxxKIAWt{1ir!Ipxy2kld;THWzB;MN^=b1A_!i?;%8P69$sy
zBwBG(5(|)rY}+NIOPPK7`!wME5xhZids_eQYHHooOifE01Ew~be%ZSw-TzBNXz+!j
zY4tP9Xwz&w*`)gmZ12z2)9M$NQ!_7j_(8el`A}?*(kMj~nv{dj`9c<&BpF&?z!xG1
zUSy&7y-mtv(1qaR4KU%PwC)qxwZEB5rySOgzJAIO`fv`fDf7T$8BfJ4%{9N7W27Ck
ze{VYd$N}`?`)g?a5^Wdh9!=sUv)6dWs*(57<O@oHSO<{Gqd3jyw4w+>U=w#7DDgB4
zuVLR$W#6wlWhhNn-?0QEtn^*p6bu>1^WggQBl^+H@2#T+%NUKf3CxwIbt+oW>EU%n
zbU26a*^6HNa4j{l@4&|PK}L`8iVK)+;NO41A9rZ@!{7p1blM-X(ZPy5ZUsg-ljMZJ
zi5$29elYcKbZq_JbR{n}ys>&Zt!vuIgNqGDC-mMq>nU^W&x3+<c~;^>-UG3Omp05R
zv@xyDHRJFByVAdwzss+C>JmkQ5dj!w3BSt9m_Ddn^&fuAeNoFgSC*7r6dr-Gapu*|
zC`lxTB@O6I3=kL*nn<}-BD4%+jZ1MmmL9;_Gvvmw(}Z!fke3nq@$S~H-MXZ{K@le`
z?v0MP5!?JZ^9_6dVBbaG{(a)aQ4{Z<aKoqhby6(DESR^DE;{3D^zWyh57Dy%A9iFP
zuoR*`%ujg>M3|FHEDqzt3dzUOqB7mt23@Maa}MD07rL36z|Hmv-hiY}XA;{dGBCpi
z$jlPf@tW||lU}3OcYB6rT=@Z&cdDdK)7J;AR>tzbFE+65yiX!6=rvcnYY(dAH$fKv
z0aK0s)u>cfl2Q~K<35z{(3upC)976bwLB%ZHfKp`2^QiP>=JrATZ4Lkoa;T!<|Lfj
z>Ed7I4T2ZkJcACq>^-{f?s?Ryx}0V#Y>3E*4Ntr(Gm+RQfsn7Qjvv+4EF0X9O}ar)
z-*pfKu-kr-#$o-=y?1BYbY}`%T0Wj>-6v=RMeobU>+Jja?E9gP@3Yu<6VzDl;IPRO
zVYltNnGO%$^T(A93@5ieU@)=M=x%}UtBh__R<WIwwhEOYwxW*Z)kl;Bb2BeG@FyO4
zinGFFmO_l?(2TqZxTImqx&?Ftzj1NWt3RY)&3c@=RduEXShfgc%3!XIUgk}f2;0=w
zn?a5&47ie1qWCbn>j3J@Z-P9&_)Q~8%SK~MEh&{GKC4#vFJ-_BINT;$C{w+A!p#S!
z7^XTrbR=uu)`&o&8OX>YC(2dAoKar91&IR*+XM?UcE+@sh5@f^K79XUrn5$eJ$Kez
z>f5gmec_a2>9fZlVQ8>_0r}4ydw8g1-8xy@KK<M;8Jxf8AtVeE@4WGzNln;&XFC6~
zvuXIKVLnN0e)&>aSH*0}Ui<B7Hf1Vdnh#2o8|Ri-E+m($aEO&^o>2I5(!m1;40-?t
zy!@qWLGv*Im>Xy07aE`S#*1MWZpd=u#myHKwz0zs=x_t}Ds&ptmCC#Fv>~qvBV8G+
z3D@r3i^@1%&HExo|71M1@KVRBe=nyl+jgV=Ck>{m-ZfM+qzeuI_BKZ3`uElvjTPAc
zz;Y^hN*FRtx+f;m<fhR7)FJ$qNE5C3k2~YV8=GSI)E3v~&5=gAX+VkLkU^i!=%Ai#
zeJN#Ov0FEq4r5lRX-IX`npbVWX>ijnO!+nL&g=EV>pM~BnsVyI2hxB6zbn@-(*5{b
z5!akG)GT$p^8Q*HGpG|C%d-%DYAa|^pK7}F1eyAuHfNJ*w>^3P!wCN72xQ_I&S}U&
zfZSsb>|@@3cysD{(?)fWP|JKn9b1NRx-PH<d}$#KZ=PUdo+`U{D>rs_F}_#O$okII
zvzD(yE^`cudUUHYzJD+9{blxjH2aPjn4au=J^OwMFa023p9BK-e!%xGolu^TDdj0`
zp6Iv(dK%x~n!3TvP+-u3>%0f+9l^A)1!V>q*h?Yp4TA{TBcR<Wp49o%O=eJG6!QrW
zYbXc9!%yp`<BuJr@cs{8s;KYO%PdcHsi-#TuEFxfw%rC(XI{4GUe$%ZI_e0s)bak>
zxm4e|7wyYS8eMt+M9-?Obkg8`jp|t&u$<XO;2&7ild!)+Wx7iuhxh*kEpJ#uQ`g%K
z+7N(!6ULSpKDS<xmV8hO@Yl@B7&Br|C<`~>8y{Wjx>Elk19{(E4e!0HqQOJz&3-+X
zE=)7MSyD<U$B-_t%;q;=$}OW}w8k!N_yt#pU_9Y#c<-(E&EA7L-rP8S>MZkQzxV#1
zR5VrbZ?GeeO_C4Z`;dV@c<;k>`gy0A<q0fNELpUamM*bR9k4C5j~l`AWh-a~%N{vq
zIBm1TSi)WiY{Jypi;y<dDhYg#;-JG0FnW$Z`DkM&mP!y7IX=Aa_y9feAxTRvbrNL=
z*F;dWnpH`Xm!*m<g9PRCW4WL(K#&VdE-Om~JrnsY8oQfWHB0&1=OxR7rHh_N$xRW^
zG573BEBH0H`QMvDeNP`s!*}X#h+Fu*`6*|=WfWKN2Z;t>IEn^eJlf!z*YI~F?wUnw
z-;}4c!RL>pK1a#&6$rM!XE$2<w*@r&dmr+CigN0{doNo2mwATQy%+`=K5Gm3mKnY&
zhPI<mZoMIG4|8j7w|cEV*Jl;#YcR9$icE=B7CuO2>)kRa-a;gG>f!xp((ZQS^v^Hl
zjc_lmpdbI=Li!@Vmb?A%E{1SJLkoT5r?bu19kKcFv?B)48N8f<u#Vqsxc8sS=>6bL
zoRbglPlxQ@!{BiG3CnymkXchzPCJk7N`HTzm$O0&Nu1)@^0UB}TiBK?0c+*1?^=&$
zjsVLF{D-G`#Av`+wwdVIdHW?J%=aK}{l7)@1%4~Z_5Eu<o5lAf?)2FAGuZdD9N+)U
zzP~$jz3I45Icxy?F4qcd{^=znxja|Wt@kb>{=vx5cRWdB=0ooTr?D-$^{|qDa_<t;
z{tSIiA;?1lWE_0df#%H(kYJ;wZAZ4|wLCy`<iOqN=z4oUzh%cW=)MIn(x2x&OGgaY
zjdtrb24u9daUESV`Ol`zI+a(^S;HsMS4PS+>@pq{+&%lBG-EwxBHQRl<~zobdD~8B
z(!KLvpg*!q?4Q`D_xAMX`Og`-?&&DDC5g|qS$W`*3rD>_mf_6}3?eZ2I{cVPwD-Py
zsyO=QcP^vno_UG>aQ9zAn47@M2N8uX(xhz}=b$zVfc3Y-gq+{na0^%M$5$xNKlM`0
zZjm_7F4quzdtw9cq1eRx9|{S0>jSdgw?hiyPih^my>V%Kk%~4$;}QbQ6$_9(d;;Ok
zaz-05H$f*(<AbJ~@A?5<eClPKvU-uiAOcS}Sp)RqhF?9j3$^hpY>f-O-Q_H>nxCZF
zc;{S$xAQ!kj_kH%r_83=r-FPOxJ^pBeHyjiBo=K*Be;^IX*U<8Q(loEZNjD{^~1Yv
zqDxM_T)`&x`65WpKx6c<ExevTl+?^?`Ab$dMc6Ri+rL*O?@uZ-Z)=E;+C>Ygz#?oN
znz@;Mzu5B~3gL~}oX4{g2xiS43G<YR!3FGAYlGQ9rXAF$%Ix7-w6Y<<o6DMImC*p>
zJ3qK^xyYgemmuV^EL~5>phb1d{sxfnCzrXSSB=qHgmIt|8)Ux&W)>kQH$b-eWBQx!
zxSqat`ZwSdi{RM`qXY8bmjqV^_z=uFK)Com{E;Zgz;_`uKoWfK$zQfar@W$JtwBlI
z8Pk<CjIH(%6q|5$#}arzm;OgFZQdovYL(8`s;w?QHO;)8J9jp-^R7;pr-eVB(!k$U
z(!F{vZgZsZEeyPs=zkL<>u+uF_|}FbCoRS1O%-C#ie>K9c78im_B!YF()?T<L!q|F
z4L~l;GV`QSygoE`oo&$Pr>xS{9(<6>4S*Luh`<FXH;4w_a26NZ_)9dK%(N~v;3($S
z0UnnZ>D-`_<FUE)X%LlxSOyMyYfa-y#=$o293-7g3ygZ~r=ys(($vz3>cJj~qyS%C
zzoi?pusFU2;ig)_s-G=9aGbjg@84K>9RKEoC9Rdq^@L>rew8w)Z9L)2fI><^_ex;F
z0G&=54+7B}KI;Gg6Us?MK~&}}<+l;|4{r&Wx@CUd{I_s9-anE67_L_UAg!E#-3c8o
zHdmrEZsoTwR0haEgX<c>>E}&FU=V><DG}?;tjUAeR9;Yn%&33x3%=twC^Q7pg+~ol
zq=^C4)(}CM489BD2T()T@<tgz2;K?@-sS|GtU>UFp5x>t)jMS4GvwGzspVa;K2wjV
zv8^{~+bq_?a3Ha@IoVP6bd+4T0<!7=ojrnv7F<PXGW-h-x&hMxgEn}j(-?FJX|i3M
zOz{c?XLOc@%tSz!+Jtm`KoizrQwm9seR?;KwChb&l1mxIBy*`Wf3`v4zMQl?^vg|L
z>dv*tP5Uyk=mLK>I#7u=S0|=;U4EqHuuz-wEwp)+S&W}n%H~bE%No9B?UY-1_rK}v
zxs%6hi{hVpYq<cCXM4U1%sM={<P}8l=n{#Rk5mP6=)5p^fGm`>$VMlRL5X?8g2DK`
z3B`d@gV7QUBCKs9BM=pk3M|0TqmcomLYdS_S{+C^tw3oUkkaPFO6wr3msV;FnZqGT
zUtN6OLTxH4>Ph|x8+L>sK(DDE&g!e=QY!{s*okFeRw!Q(o%yIb5TB*6Q`8#|lL{An
zSlgLBb8d==(xPBXnmxs6Q<<fcn_Z&nR1V!(hbMb9TpWPe&MDb{x3M9OPFkniw86`5
z4LH3ZiYYPS!O{kTYr9~wonfEaVL8+biE-|jpe0|tbVxwGNL@*ct!r9mS}yrC#MKq*
z3(tO-t<f^llF28}#V3_t65Qo=dkFOv{$goE+h&}<e#xrc+8(t{YFr9Gqjr}zr}jfC
zmNwjct|sYHOh?0m2wb`N!&PGV_=FfiFmjfwoV$1~Jn*8kui&lG=6eRFw83FzW6**p
zcX<vLxRh^e@S!NsTV0Y90I1EcU~=oS{DAs@QU06nyiowG*97BGD48vGLo^4Bfp|PF
z2dg*oT~0rZydEf3J?u3o*B{!YwoSCv^t`=>Rh}Q;bk~icuCm~}A^0u?W+G5(#Rsl=
zUc!^Y$tR^fdh*H6fY*9=Nayiek$71mU#N5|GL9JEUg*N#R=^&FLYEKX<i)}A*$~H*
z1y*{w`6Via8=EHtHdq?3VzRX@ziDZ+4z9`I){vz%gvM&m<w?WA_B6aN4fdgf%ngv@
zdzDMoeh74^#jZYuiH2xSH~_;Tmk(+$dr(bs%MR|#%&u@qaxKd)St!$Zqc~WQZoAGd
z#rYQpQ(M&+#IB#fD^6+MSaC_R^WjyN(rF%Xl1!H-jxP<b^f|Kmh6^0l&C9s6)&Ya*
zw9U>|V3o_p7({3=5}4N98)S4L-)sPZDh|@nV}bJUAT%x^Xe5Yr)&e)BG$vLvjTn^`
z#F`Bl9MeP3fO6phX(S5qjyxnoxJkP?9~TkVp&8hPS30rShJn78V|$dsv$WsWXpiht
z^1^qgii~LdN_QvT+mU78M!2+*X4Ja1>&!={N;Qy(Hk&lfh2css7ZUwuA8(VZ8)=<o
zkPg_z3V$xd%5^JLDp;Ddq=imsTuRHIluFZ?ixUXWcpA`7CrP#scLzK^E_$md%!gcA
zX%Jtw^~vSZK~hp(xwLU<XmR~jt%&_{Rh%m)j?TsV=`{K%&gNi;Z;P7;Wl{i6Z>y5d
zz3I5TR%<+6nl8x6hj(>px)>hi%@@0}-7>@G1mN)73K$Sz9|8swG7Es&CT}Pm2vQlY
z+_2Mffohloiw-K7z`-ebE(}DfHKY>eIDVHTmJ_lt2tshrnlp&-WX4uuE}q6g7nD@<
zH3qYrjtT=tY<J;GzlrOyR0D`mKC8oCm(qG2N-tdkZP}ZVz;9x$UvD?crYXxbkic(X
zbmt$tDn*cHR|-j1M(JcilH1rcZFR+^&;iMzOB97$q>UM|d((FHDUF4xy%wS=A5)k`
zmRkK%xmjX#s@^R$3tI=#L`woW88B#Uea&KkUq8N|ejWLF)#1Z6pVb=BE3KObOb$C6
zp>(R-ja9D;Lt2-}fKQ@vd3+mOT$Z$NV-}rR<d&MowJWq4H(~BA(FtKN;SMO`^t&=b
zd@L};+C)aW(6*2>BV$N!+m{34wgt&{t_wNUr7`Hu;K2m|m=NMD15Du>%bih#SXfl3
ztI}QpYNKFXIPO*W1UdqiGCCq;nvp;!p5#<V80E<{16fahZC$PTxd@LmHk)xEvCMn}
zB3431pj*KiSyIVLEzc@b$r@XXrhw57RyrlOX)0BEtaXN12M#WW;$2vw>0}S0lA?6c
zT%j`&uv;(3WFG{RjE~wUIkhVbm!(AtwWEUvq!k;d#fL!~>IXhaI!cknnkYwl&X<>D
ztHQ-Uw8wbAl+M?xdekSs4XVFBpPN@13Pax4hrCax^lqGm#--mH(z!Nc*#Wy=ypT)i
z5tKIT*FmAuU4Hj^0bCB3LZs(Ha<%%!pm{$QPKCO1q>ZaCjX~k2U5=zQ1`tib;1B7J
z3w-b48Hqye>o|K7By$m%!GweE+qX9lB<v63IjEc@?yq^n%xSY|haKg|vGNjo1Sr5#
z6{5;2jXYPHraj|>EU=i~$A+Hj;K1jnkx#mT$4NqSMWe;jo^C`#tT%1o^@!t7@;eD0
zC&PzDd2LP`hK2Z?@p<?MACiN`7AD&*8F1>Mn&g&;Gi=8QSw0ai_2zDnR1QCe2CW}F
zUFt8BVzVIXC~H0Wa@&))r6nH2H{E#VZZPx9QuA7B8p8+O;3+ZMU$hOvURN*jZcte+
z3~AMgg!?7G5biT<WqI{E$-hK%)j?*&^spYL5LIX*b7>GTL60mFl@>ADls+(^O+_~^
z+V%!I(8mQWv$R<Glt%Mvi`Zf9fla#US7Kde6&mGBvPtD@483UUjl6_`Wen_v(3v--
zDRnHX8d)tYwf4f~nWYV9d1Kq{$Ixv4B6XIKX+~no2h(U7e_isZ;|`}s9(=<5<aV0y
zQWjh3WMz}2RETltKtV1d#in_0adN>($Le1^N)<{(0z^r{!+Y5zu2guaJEXExmhiXG
zpdC^?Uz&6A98qYlwF0qEDagx_?Fk^Re$+~hqc&`woO){gDa<ceDZYulHZ5NHzWMol
zUcxTranqL14(eL@hK(DPOJ{DbmRM4OK$YvGOPSBAL+N09YEZ&dqS7Gq+Ty5jX(jER
zwM{t;oGkRZhwHAMsI>T8q4d6#q~cD4<KBdydp9u)%=ftC>ntkIj^bM$?e(`P-Ni6*
z0iq0R_><oUPTZfr8oiRgNIf%?q_S-W@0e8n5drvB%+K?uq<5S!-h5j;g8Vr1aS41}
z0w0&a$0hJ_34B}vANdk!YHFhQ-kD7I^Uqdn+!*}|aguYH2NEg(@5Hvsmr@L<l%uUu
z%2IpN#>>zr(`hmtuG4##H-8GFFpO?x>f6pffYbFSnzlKc%C8F)?x;`F7GhJ$vXb@L
zCwok978+!?bCfHKJ?c>!t&ZtsR>;m0MYYA}AXn>0(yB3@ese)l!g`2b>SZ<y@MM+M
zpSaqLD{mKOcw(jwER9WBi{XPT_u<V2d?NuLO~Rj+I`HNTjXX;sZ#Re>Y*0kNn-1a`
zb2!ti1{rgTvm%D9-JrNKY`0KHKvwxa9r9A@B24m*;5<o`pO&G-TKXyv((S!0PJbR1
z5wz-3pyoAJxW>imgFMVY@JFZ3CRmlXIb+O5R8{d074j2)zR+wwk<Fh`cly?RJf+50
z@^4>t>cpSPuH@g8DbS8gOB=4i7)1D$>*5PdmrhoGNua<XYj4pDun@a(tBV^r6e6P(
zwD859G?sj_WZ>h1+$yAOuohWpNLpviXOHL+syMB%%N;yqu?sg4f8gNq$!#)Dn@g21
zt+&1GazKfrP=8<vv}yM${s9^v;w(~Y<2mA?_&o>h+)-xohgPovb)yS^48x#<JAVBG
z6~5dE3bawNL9mf8G%_6q3^Lfj8aPTw>JYD0`h$sLd@%xxJjIn~p`ug<Y}a&F8A^{>
z2MjJOiyY|Ha+9>?L?&d2e5)giT+moaSvjI~h58cZ&ds5PHM3B>fsu4y%H`@H2-{JH
zk5PR@0<JZ46gY^0dj$<7N>wE7mjelC!uciXjT;>#sP$sxWafazsRIYSmA3Z+N>i@h
z#nGhUKp%$(EIvq?00$Z^t9aUYsCIDi*ep;jNv$8(4r^bMB<Y&$Mo7@9#H2PN-I{i8
zNs_a`ttPiEYI$p!O4lfDFP~IMjPnV6t~OVW>hoz_xS?kNU^#LCa1oq_4f+NGP-fV`
zGYkmkW)n!!0f0;%L?z>@DQBK?{`diI>Kf#Fl0kyju=(sW6Ub+yg|ZUAGhv1peAQWY
z6;tvUewHf4$%=!iKE)xHLrX^TN|zLC@gUZ;ORMswEn3+wO}=!TT;);uNqL1Q#c8sW
zcw9K{LwJo7GoyO1cJW&#&E*_3tG8ur$*<L1!*U_#C-x{Z4J7<V;>pOAErpDzqFjjz
zkq*&5&Em3ATvSGUPHuE^L24S5{zY1d%y>=7P?a6IzyOQ@^!^`3C~vZK@I|RmW`!>8
zXxVrsrKyeJ!~(aTa_x#Ra7O9?nl+tMBo0f|M<86k6<fId;8ZS=2#9|~wLyC{s04W9
z`=huhM-e$T%Jmr%U?+m;;Bx>llL~?|ShWE$ej*ACD$9*wJw$*`JmG{%bDnQZX2TgH
z1ur<sq3$ur;9&;n^e+$wm>Z%w7gJnX%b_@K;VMLiORH(|IVwwWadv4LXdFiaepiN@
zj-v<6mFK3F-j(5|6^}Rx?$We3t+pZ7>jq007^vbcB)9#wS66%aQ67br38>Y>_G&MJ
zpRYIhQM$r;V+Rt2IiIYwRB}W^yfi@VA)S&AB$6$QVx;P%3F>H88miDCt=ct?N+?~<
zmyf*PwBlgaLfGPSsC^>c*HPRcB03A88vNL`RrMmahjvLmr{u*GTQ};N#_?Q*L0ud3
zaatcFg|oId#U;s5oAm~WJlY$A;v`qtS$Tc^fNSS0C9aezUnr1M4BwLtDfrx*vZggw
z?^Qkq3&t;}^EY{h>Jo_2p?IdppU!BBTp5tymv1eP3}DpaVq?E-I#Q0S%TJ5fqTR*C
z*`sv=oS#-+KaP{5Fjq#LOu$s0rrkVXe#nRS>HWNKlj0SQ*rv6W2n?UIM*Gn=q`X^A
zjKcYd%t)x2ZTyoMZRNqD5DK1sK$|teM4SV0kQRiqv=NXhyy&<zav&w}BE}Ncp&g*c
zF{G&=G)o;gAl3%!GpRlwo|ezTlZ6I4Kxb@AFi_<P+9gs>p-?*4ZorD!7a^U5D=9e*
z9eOyc>d6d@(VIhBy`&1rh;&QKWl1V4z_Sh<RGw{TQje}qq#@IVfiF%!;Auf+#PLc8
z7Tg2^A-Y5%w`TxZf??+O_jy^tK=70j)`kHIJUEBEhBeT_`zs`cdPEJP%*r{%&y0by
zig!0x1}L^dItTFivl4)14RPg=l^1kb`F%R%<$#yj<)Hrb;G_vE+m98W7OO185;P@t
z0j6@%rZ-nmD^#Crr=*2K>HHW22<hq+qms6+Slf6OtF)bLPLE_fAZ<Z^SFEkMnVMSo
z%Q<X_UfZ%f!*pyUzS0>vf)PmGAMMIo2wCW|(`a!b)}}5gbb2~)u$b(U(Lw2lcvMSv
z?ov=DTb+yvior1$v`*F-Ca|a!d&|hR9hAikB2b3XJxHDScBm%E&)Vrq=OI3+Y?ZS)
zV=X;5&gz5O=?{Y3@^RBj@55BL;@ca`0)j}fKV2<#hxUPOmAK4QFYJ*HTr4xQ1Hlag
zQczczSkNJcNESHGyye?~L^j`eAQ&ejSgC_IG<1f7!J<v^X*s3Ijn#)-Ogf}cKI0OL
zlvu8^EHcz9uPBUhDzlJIUFAru(#2P`P1-MDSu7OZ_MW4b*t%7FRld?m?4FfEtZrq~
z<=$;tpG9u%sm)j9nMwkeA%^)faL6^zJX~m{1QOkQ0r8B52E4&pUcuX=`G{TGP{Oo0
z*Mv0cVsLVC;vz7P2XUd2w1d*l&nu%s#kHG0Qf|m(Gze49K4~0#M1G33ptCoa6haRL
z8+<!JqI#`dg?IvjtjLi8i7U@d$8#12b*+d?114~3Z-q%0YTL%7Y|?yyF3_viIDIbG
zwb`Xj)FBFll+)0qn<fF&&Ru>;hymP@8+%xw41h#3=*%DAdGLo2P?|JuNEm{EKW@gt
z5b+7RTLNQ^o&bRXO(8)nfDJY%%tErK3gHE<J)|_U@WWQMS7R$juD>i6E3e3NOHu7I
zHDRpGVpkTOS!u*3p;kN7c$G%&)EGS4&Rm%J!YtqX<n?mpPSdaz;fy1$Hz~G(EF)=(
zlvq@B@Bot1D8d_@ZEgHR>&-3M2NI=G9p|T&jFcYsEeqSg;<$a7-t2Ij(kDaEY{@2Q
zJq)Y`00tFe6!T;qOaxjIBdFH_S|U*b!Yxyfs4T?!Y6^9OdQrFi*oa6tiTo(ig=sn(
zYtHiJLM$#zN~%q6=911{mFlmQT7GS?6`z{MpR{W|s{|`CBF%GBtOW%S!N9_>>aAP2
z#UGIwzSF|{6|6W(;S4CIJTV}N3<?~RtX`3?XNN>VCboJa;7BG5O@x6nS$UKWu^g`N
z$#T>mja9$OK_1szz5sreA+hGbDYoG3%2J#2$u0)3+TB>wt~}oc&HJ&-gS6sZxXRbx
z!O$fPg}byLg>;;c@pfmYjOWjVVgO<KQI17=>2=7=WE=f|O%WkGaZ@3600000NkvXX
Hu0mjf+?nfp

diff --git a/forge/lib/abdk-libraries-solidity b/forge/lib/abdk-libraries-solidity
deleted file mode 160000
index d8817cb..0000000
--- a/forge/lib/abdk-libraries-solidity
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit d8817cb600381319992d7caa038bf4faceb1097f
diff --git a/forge/lib/ds-test b/forge/lib/ds-test
deleted file mode 160000
index 57c31d6..0000000
--- a/forge/lib/ds-test
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 57c31d62aafcf8edd015272cee91eec1b2e9db3b
diff --git a/forge/lib/forge-std b/forge/lib/forge-std
deleted file mode 160000
index 8f1a972..0000000
--- a/forge/lib/forge-std
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 8f1a9720250512a49c6638979a87613700e2a68b
diff --git a/forge/lib/openzeppelin-contracts b/forge/lib/openzeppelin-contracts
deleted file mode 160000
index dd01889..0000000
--- a/forge/lib/openzeppelin-contracts
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit dd018894345a99e5058578cd0dc15bbb31b631b3
diff --git a/forge/lib/perpetual-pools-contracts b/forge/lib/perpetual-pools-contracts
deleted file mode 160000
index 1ae17f7..0000000
--- a/forge/lib/perpetual-pools-contracts
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 1ae17f7c2994b6d072c736390d1c8edb0c95d9d3
diff --git a/forge/lib/solmate b/forge/lib/solmate
deleted file mode 160000
index 7136e46..0000000
--- a/forge/lib/solmate
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 7136e4624b53b224859aa518cbb56c8d92a996d8
diff --git a/forge/readme.md b/forge/readme.md
deleted file mode 100644
index f00863b..0000000
--- a/forge/readme.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# vUSDC Vault
-Vault that accepts underlying (USDC) and deposits into stargate to collect and compound STG rewards into more underlying.
-Swaps are conducted through Blancer on Arbitrum. This vault is configured for arbitrum, but tested working on ETH Mainnet. 
-Too launch on another network supporting stargate, simply change the `underyling` `router` `POOLTOKEN` and `staker` addresses. 
-Rewards are compounded with an independent function by the vault owner, but can be configured to compound on deposit through a nested if statement. 
-To add a `fee` call the `setFee` function, fees are collected on every compound and sent to the `feeCollector`. 
-
-## Install foundry
-you will need foundry installed to compile and test contracts in ./forge/src
-```
-curl -L https://foundry.paradigm.xyz | bash
-```
-then install foundry using 
-```
-foundryup
-```
-## Getting started
-update lib's using
-```
-forge update
-```
-build contracts using
-```
-forge build
-```
-lint using 
-```
-yarn run lint
-```
-## Testing
-To test vUSDC, run the following command:
-```
-forge t  -vvvv  --fork-url https://arb-mainnet.g.alchemy.com/v2/vkR4jribNoIWslgAymd5F8zQ1Ny8y9xL --fork-block-number 8623683 
-```
-The above test forks the Arbitrum network at block `8623683` and interaacts with stargate through the vault by replicating user deposits, withdrawals and compounds
-
-To test reward reciept, `testRewards()` will need to be uncommented and the test run on ETH Mainnet. 
-## Gas Report
-<img src="./gas-report.png"/>
\ No newline at end of file
diff --git a/forge/remappings.txt b/forge/remappings.txt
deleted file mode 100644
index 45dc358..0000000
--- a/forge/remappings.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-src/=./forge/src/
-solmate/=lib/solmate/src/
-weird-erc20/=lib/solmate/lib/weird-erc20/src/
-ds-test/=lib/ds-test/src/
-openzeppelin/=lib/openzeppelin-contracts/contracts/
-foundry-playground/=lib/foundry-playground/src/
-tracer/=lib/perpetual-pools-contracts/contracts/
-abdk-libraries-solidity/=lib/abdk-libraries-solidity/
-forge-std/=lib/forge-std/src/
diff --git a/forge/src/interfaces/IBalancer.sol b/forge/src/interfaces/IBalancer.sol
deleted file mode 100644
index b519a38..0000000
--- a/forge/src/interfaces/IBalancer.sol
+++ /dev/null
@@ -1,50 +0,0 @@
-pragma solidity ^0.8.6;
-
-interface IAsset {}
-
-interface IBalancer {
-    enum SwapKind {
-        GIVEN_IN,
-        GIVEN_OUT
-    }
-
-    struct FundManagement {
-        address sender;
-        bool fromInternalBalance;
-        address payable recipient;
-        bool toInternalBalance;
-    }
-
-    struct SingleSwap {
-        bytes32 poolId;
-        SwapKind kind;
-        IAsset assetIn;
-        IAsset assetOut;
-        uint256 amount;
-        bytes userData;
-    }
-
-    struct BatchSwapStep {
-        bytes32 poolId;
-        uint256 assetInIndex;
-        uint256 assetOutIndex;
-        uint256 amount;
-        bytes userData;
-    }
-
-    function swap(
-        SingleSwap calldata singleSwap,
-        FundManagement calldata funds,
-        uint256 limit,
-        uint256 deadline
-    ) external payable returns (uint256 amountCalculated);
-
-    function batchSwap(
-        SwapKind kind,
-        BatchSwapStep[] calldata swaps,
-        IAsset[] calldata assets,
-        FundManagement calldata funds,
-        int256[] calldata limits,
-        uint256 deadline
-    ) external payable returns (int256[] memory assetDeltas);
-}
diff --git a/forge/src/interfaces/ILeveragedPool.sol b/forge/src/interfaces/ILeveragedPool.sol
deleted file mode 100644
index 069cce6..0000000
--- a/forge/src/interfaces/ILeveragedPool.sol
+++ /dev/null
@@ -1,215 +0,0 @@
-//SPDX-License-Identifier: CC-BY-NC-ND-4.0
-pragma solidity 0.8.7;
-
-/// @title The pool controller contract interface
-interface ILeveragedPool {
-    // Initialisation parameters for new market
-    struct Initialization {
-        address _owner; // Owner of the contract
-        address _keeper; // The address of the PoolKeeper contract
-        address _oracleWrapper; // The oracle wrapper for the derivative price feed
-        address _settlementEthOracle; // The oracle wrapper for the SettlementToken/ETH price feed
-        address _longToken; // Address of the long pool token
-        address _shortToken; // Address of the short pool token
-        address _poolCommitter; // Address of the PoolCommitter contract
-        address _invariantCheck; // Address of the InvariantCheck contract
-        string _poolName; // The pool identification name
-        uint32 _frontRunningInterval; // The minimum number of seconds that must elapse before a commit is forced to wait until the next interval
-        uint32 _updateInterval; // The minimum number of seconds that must elapse before a commit can be executed
-        uint16 _leverageAmount; // The amount of exposure to price movements for the pool
-        uint256 _fee; // The fund movement fee. This amount is extracted from the deposited asset with every update and sent to the fee address. Given as the decimal * 10 ^ 18. For example, 60% fee is 0.6 * 10 ^ 18
-        address _feeAddress; // The address that the fund movement fee is sent to
-        address _secondaryFeeAddress; // The address of fee recieved by third party deployers
-        address _settlementToken; //  The digital asset that the pool accepts. Must have a decimals() function
-        uint256 _secondaryFeeSplitPercent; // Percent of fees that go to secondary fee address if it exists
-    }
-
-    // #### Events
-    /**
-     * @notice Creates a notification when the pool is setup and ready for use
-     * @param longToken The address of the LONG pair token
-     * @param shortToken The address of the SHORT pair token
-     * @param settlementToken The address of the digital asset that the pool accepts
-     * @param poolName The identification name of the pool
-     */
-    event PoolInitialized(
-        address indexed longToken,
-        address indexed shortToken,
-        address settlementToken,
-        string poolName
-    );
-
-    /**
-     * @notice Creates a notification when the pool is rebalanced
-     * @param shortBalanceChange The change of funds in the short side
-     * @param longBalanceChange The change of funds in the long side
-     * @param shortFeeAmount Proportional fee taken from short side
-     * @param longFeeAmount Proportional fee taken from long side
-     */
-    event PoolRebalance(
-        int256 shortBalanceChange,
-        int256 longBalanceChange,
-        uint256 shortFeeAmount,
-        uint256 longFeeAmount
-    );
-
-    /**
-     * @notice Creates a notification when the pool's price execution fails
-     * @param startPrice Price prior to price change execution
-     * @param endPrice Price during price change execution
-     */
-    event PriceChangeError(int256 indexed startPrice, int256 indexed endPrice);
-
-    /**
-     * @notice Represents change in fee receiver's address
-     * @param oldAddress Previous address
-     * @param newAddress Address after change
-     */
-    event FeeAddressUpdated(address indexed oldAddress, address indexed newAddress);
-
-    /**
-     * @notice Represents change in secondary fee receiver's address
-     * @param oldAddress Previous address
-     * @param newAddress Address after change
-     */
-    event SecondaryFeeAddressUpdated(address indexed oldAddress, address indexed newAddress);
-
-    /**
-     * @notice Represents change in keeper's address
-     * @param oldAddress Previous address
-     * @param newAddress Address after change
-     */
-    event KeeperAddressChanged(address indexed oldAddress, address indexed newAddress);
-
-    /**
-     * @notice Indicates a payment of fees to the secondary fee address
-     * @param secondaryFeeAddress The address that got fees paid to it
-     * @param amount Amount of settlement token paid
-     */
-    event SecondaryFeesPaid(address indexed secondaryFeeAddress, uint256 amount);
-
-    /**
-     * @notice Indicates a payment of fees to the primary fee address
-     * @param feeAddress The address that got fees paid to it
-     * @param amount Amount of settlement token paid
-     */
-    event PrimaryFeesPaid(address indexed feeAddress, uint256 amount);
-
-    /**
-     * @notice Indicates settlement assets have been withdrawn from the system
-     * @param to Receipient
-     * @param quantity Quantity of settlement tokens withdrawn
-     */
-    event SettlementWithdrawn(address indexed to, uint256 indexed quantity);
-
-    /**
-     * @notice Indicates that the balance of pool tokens on issue for the pool
-     *          changed
-     * @param long New quantity of long pool tokens
-     * @param short New quantity of short pool tokens
-     */
-    event PoolBalancesChanged(uint256 indexed long, uint256 indexed short);
-
-    function leverageAmount() external view returns (bytes16);
-
-    function poolCommitter() external view returns (address);
-
-    function settlementToken() external view returns (address);
-
-    function primaryFees() external view returns (uint256);
-
-    function secondaryFees() external view returns (uint256);
-
-    function oracleWrapper() external view returns (address);
-
-    function lastPriceTimestamp() external view returns (uint256);
-
-    function poolName() external view returns (string calldata);
-
-    function updateInterval() external view returns (uint32);
-
-    function shortBalance() external view returns (uint256);
-
-    function longBalance() external view returns (uint256);
-
-    function frontRunningInterval() external view returns (uint32);
-
-    function poolTokens() external view returns (address[2] memory);
-
-    function settlementEthOracle() external view returns (address);
-
-    // #### Functions
-    /**
-     * @notice Configures the pool on deployment. The pools are EIP 1167 clones.
-     * @dev This should only be able to be run once to prevent abuse of the pool. Use of Openzeppelin Initializable or similar is recommended
-     * @param initialization The struct Initialization containing initialization data
-     */
-    function initialize(Initialization calldata initialization) external;
-
-    function poolUpkeep(int256 _oldPrice, int256 _newPrice) external;
-
-    function settlementTokenTransferFrom(
-        address from,
-        address to,
-        uint256 amount
-    ) external;
-
-    function payKeeperFromBalances(address to, uint256 amount) external returns (bool);
-
-    function settlementTokenTransfer(address to, uint256 amount) external;
-
-    function claimPrimaryFees() external;
-
-    function claimSecondaryFees() external;
-
-    /**
-     * @notice Transfer pool tokens from pool to user
-     * @param isLongToken True if transferring long pool token; False if transferring short pool token
-     * @param to Address of account to transfer to
-     * @param amount Amount of pool tokens being transferred
-     * @dev Only callable by the associated `PoolCommitter` contract
-     * @dev Only callable when the market is *not* paused
-     */
-    function poolTokenTransfer(
-        bool isLongToken,
-        address to,
-        uint256 amount
-    ) external;
-
-    function setNewPoolBalances(uint256 _longBalance, uint256 _shortBalance) external;
-
-    /**
-     * @return _latestPrice The oracle price
-     * @return _data The oracleWrapper's metadata. Implementations can choose what data to return here
-     * @return _lastPriceTimestamp The timestamp of the last upkeep
-     * @return _updateInterval The update frequency for this pool
-     * @dev To save gas so PoolKeeper does not have to make three external calls
-     */
-    function getUpkeepInformation()
-        external
-        view
-        returns (
-            int256 _latestPrice,
-            bytes memory _data,
-            uint256 _lastPriceTimestamp,
-            uint256 _updateInterval
-        );
-
-    function getOraclePrice() external view returns (int256);
-
-    function intervalPassed() external view returns (bool);
-
-    function balances() external view returns (uint256 _shortBalance, uint256 _longBalance);
-
-    function setKeeper(address _keeper) external;
-
-    function updateFeeAddress(address account) external;
-
-    function updateSecondaryFeeAddress(address account) external;
-
-    function burnTokens(
-        uint256 tokenType,
-        uint256 amount,
-        address burner
-    ) external;
-}
diff --git a/forge/src/interfaces/IPoolCommitter.sol b/forge/src/interfaces/IPoolCommitter.sol
deleted file mode 100644
index 308ff26..0000000
--- a/forge/src/interfaces/IPoolCommitter.sol
+++ /dev/null
@@ -1,211 +0,0 @@
-//SPDX-License-Identifier: CC-BY-NC-ND-4.0
-pragma solidity 0.8.7;
-
-/// @title The interface for the contract that handles pool commitments
-interface IPoolCommitter {
-    /// Type of commit
-    enum CommitType {
-        ShortMint, // Mint short tokens
-        ShortBurn, // Burn short tokens
-        LongMint, // Mint long tokens
-        LongBurn, // Burn long tokens
-        LongBurnShortMint, // Burn Long tokens, then instantly mint in same upkeep
-        ShortBurnLongMint // Burn Short tokens, then instantly mint in same upkeep
-    }
-
-    function isMint(CommitType t) external pure returns (bool);
-
-    function isBurn(CommitType t) external pure returns (bool);
-
-    function isLong(CommitType t) external pure returns (bool);
-
-    function isShort(CommitType t) external pure returns (bool);
-
-    // Pool balances and supplies
-    struct BalancesAndSupplies {
-        uint256 newShortBalance;
-        uint256 newLongBalance;
-        uint256 longMintPoolTokens;
-        uint256 shortMintPoolTokens;
-        uint256 longBurnInstantMintSettlement;
-        uint256 shortBurnInstantMintSettlement;
-        uint256 totalLongBurnPoolTokens;
-        uint256 totalShortBurnPoolTokens;
-    }
-
-    // User aggregate balance
-    struct Balance {
-        uint256 longTokens;
-        uint256 shortTokens;
-        uint256 settlementTokens;
-    }
-
-    // Token Prices
-    struct Prices {
-        bytes16 longPrice;
-        bytes16 shortPrice;
-    }
-
-    // Commit information
-    struct Commit {
-        uint256 amount;
-        CommitType commitType;
-        uint40 created;
-        address owner;
-    }
-
-    // Commit information
-    struct TotalCommitment {
-        uint256 longMintSettlement;
-        uint256 longBurnPoolTokens;
-        uint256 shortMintSettlement;
-        uint256 shortBurnPoolTokens;
-        uint256 shortBurnLongMintPoolTokens;
-        uint256 longBurnShortMintPoolTokens;
-        uint256 updateIntervalId;
-    }
-
-    // User updated aggregate balance
-    struct BalanceUpdate {
-        uint256 _updateIntervalId;
-        uint256 _newLongTokensSum;
-        uint256 _newShortTokensSum;
-        uint256 _newSettlementTokensSum;
-        uint256 _longBurnFee;
-        uint256 _shortBurnFee;
-        uint8 _maxIterations;
-    }
-
-    // Track how much of a user's commitments are being done from their aggregate balance
-    struct UserCommitment {
-        uint256 longMintSettlement;
-        uint256 longBurnPoolTokens;
-        uint256 shortMintSettlement;
-        uint256 shortBurnPoolTokens;
-        uint256 shortBurnLongMintPoolTokens;
-        uint256 longBurnShortMintPoolTokens;
-        uint256 updateIntervalId;
-    }
-
-    // Track the relevant data when executing a range of update interval's commitments (stack too deep)
-    struct CommitmentExecutionTracking {
-        uint256 longTotalSupply;
-        uint256 shortTotalSupply;
-        uint256 longTotalSupplyBefore;
-        uint256 shortTotalSupplyBefore;
-        uint256 _updateIntervalId;
-    }
-
-    /**
-     * @notice Creates a notification when a commit is created
-     * @param user The user making the commitment
-     * @param amount Amount of the commit
-     * @param commitType Type of the commit (Short v Long, Mint v Burn)
-     * @param appropriateUpdateIntervalId Id of update interval where this commit can be executed as part of upkeep
-     * @param fromAggregateBalance whether or not to commit from aggregate (unclaimed) balance
-     * @param payForClaim whether or not to request this commit be claimed automatically
-     * @param mintingFee Minting fee at time of commit creation
-     */
-    event CreateCommit(
-        address indexed user,
-        uint256 indexed amount,
-        CommitType indexed commitType,
-        uint256 appropriateUpdateIntervalId,
-        bool fromAggregateBalance,
-        bool payForClaim,
-        bytes16 mintingFee
-    );
-
-    /**
-     * @notice Creates a notification when a user's aggregate balance is updated
-     */
-    event AggregateBalanceUpdated(address indexed user);
-
-    /**
-     * @notice Creates a notification when commits for a given update interval are executed
-     * @param updateIntervalId Unique identifier for the relevant update interval
-     * @param burningFee Burning fee at the time of commit execution
-     */
-    event ExecutedCommitsForInterval(uint256 indexed updateIntervalId, bytes16 burningFee);
-
-    /**
-     * @notice Creates a notification when a claim is made, depositing pool tokens in user's wallet
-     */
-    event Claim(address indexed user);
-
-    /*
-     * @notice Creates a notification when the burningFee is updated
-     */
-    event BurningFeeSet(uint256 indexed _burningFee);
-
-    /**
-     * @notice Creates a notification when the mintingFee is updated
-     */
-    event MintingFeeSet(uint256 indexed _mintingFee);
-
-    /**
-     * @notice Creates a notification when the changeInterval is updated
-     */
-    event ChangeIntervalSet(uint256 indexed _changeInterval);
-
-    /**
-     * @notice Creates a notification when the feeController is updated
-     */
-    event FeeControllerSet(address indexed _feeController);
-
-    // #### Functions
-
-    function initialize(
-        address _factory,
-        address _autoClaim,
-        address _factoryOwner,
-        address _feeController,
-        address _invariantCheck,
-        uint256 mintingFee,
-        uint256 burningFee,
-        uint256 _changeInterval
-    ) external;
-
-    function commit(bytes32 args) external payable;
-
-    function updateIntervalId() external view returns (uint128);
-
-    function pendingMintSettlementAmount() external view returns (uint256);
-
-    function pendingShortBurnPoolTokens() external view returns (uint256);
-
-    function pendingLongBurnPoolTokens() external view returns (uint256);
-
-    function claim(address user) external;
-
-    function executeCommitments(
-        uint256 lastPriceTimestamp,
-        uint256 updateInterval,
-        uint256 longBalance,
-        uint256 shortBalance
-    )
-        external
-        returns (
-            uint256,
-            uint256,
-            uint256,
-            uint256,
-            uint256
-        );
-
-    function updateAggregateBalance(address user) external;
-
-    function getAggregateBalance(address user) external view returns (Balance memory _balance);
-
-    function getAppropriateUpdateIntervalId() external view returns (uint128);
-
-    function setPool(address _leveragedPool) external;
-
-    function setBurningFee(uint256 _burningFee) external;
-
-    function setMintingFee(uint256 _mintingFee) external;
-
-    function setChangeInterval(uint256 _changeInterval) external;
-
-    function setFeeController(address _feeController) external;
-}
diff --git a/forge/src/interfaces/IRouter.sol b/forge/src/interfaces/IRouter.sol
deleted file mode 100644
index 31e2e6d..0000000
--- a/forge/src/interfaces/IRouter.sol
+++ /dev/null
@@ -1,16 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-only
-pragma solidity ^0.8.0;
-
-interface IRouter {
-    function addLiquidity(
-        uint256 _pid,
-        uint256 _amount,
-        address _to
-    ) external;
-
-    function instantRedeemLocal(
-        uint16 _pid,
-        uint256 _amountLP,
-        address _to
-    ) external returns (uint256);
-}
diff --git a/forge/src/interfaces/IStargate.sol b/forge/src/interfaces/IStargate.sol
deleted file mode 100644
index 19a8673..0000000
--- a/forge/src/interfaces/IStargate.sol
+++ /dev/null
@@ -1,15 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-only
-pragma solidity ^0.8.0;
-
-interface IStargate {
-    struct UserInfo {
-        uint256 amount; // How many LP tokens the user has provided.
-        uint256 rewardDebt; // Reward debt. See explanation below.
-    }
-
-    function userInfo(uint256 _pid, address _user) external view returns (uint256, uint256);
-
-    function deposit(uint256 _pid, uint256 _amount) external;
-
-    function withdraw(uint256 _pid, uint256 _amount) external;
-}
diff --git a/forge/src/longVault.sol b/forge/src/longVault.sol
deleted file mode 100644
index 1eaeb2b..0000000
--- a/forge/src/longVault.sol
+++ /dev/null
@@ -1,130 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.1;
-import {ILeveragedPool} from "./interfaces/ILeveragedPool.sol";
-import {L2Encoder} from "./utils/L2Encoder.sol";
-import {IPoolCommitter} from "./interfaces/IPoolCommitter.sol";
-import {ILeveragedPool} from "./interfaces/ILeveragedPool.sol";
-import {ERC20} from "../lib/solmate/src/tokens/ERC20.sol";
-import {SafeMath} from "openzeppelin/utils/math/SafeMath.sol";
-
-contract longVault {
-    using SafeMath for uint256;
-    ERC20 USDC;
-    ERC20 THREELBTC;
-    IPoolCommitter poolCommitter;
-    ERC20 vault;
-    address poolAddress;
-    bool public tradeLive;
-    uint256 public threshold;
-    ILeveragedPool public pool;
-    L2Encoder encoder;
-    event holding(uint256 _amt);
-    event unwind(uint256 _amt);
-    event releasing(uint256 _amt);
-    event noAction(uint256 _skew);
-    event Log(string _msg);
-    event acquired(uint256 _amt);
-
-    constructor(
-        address _poolAddress,
-        uint256 _threshold,
-        address _committer,
-        address _encoder,
-        ERC20 _vault
-    ) public {
-        poolAddress = _poolAddress;
-        threshold = _threshold;
-        pool = ILeveragedPool(poolAddress);
-        poolCommitter = IPoolCommitter(_committer);
-        encoder = L2Encoder(_encoder);
-        tradeLive = false;
-        _vault = vault;
-    }
-
-    function checkSkew() public onlyPlayer {
-        uint256 _skew = skew();
-        uint256 _bal = THREELBTC.balanceOf(address(this)).add(agBal());
-        if (_skew > threshold) {
-            uint256 target = target();
-
-            if (_bal < target) {
-                uint256 aq = acquiring();
-                acquire(aq);
-            }
-            if (_bal > target) {
-                uint256 ds = disposing();
-                dispose(ds);
-            }
-            if (_bal == target) {
-                emit holding(_bal);
-            }
-            emit noAction(_skew);
-        }
-        if (_skew < threshold) {
-            // TODO: check if this is correct
-            dispose(_bal);
-            emit unwind(_bal);
-        }
-    }
-
-    function skew() public view returns (uint256) {
-        uint256 _skew = pool.shortBalance() / pool.longBalance();
-        return _skew;
-    }
-
-    function target() public view returns (uint256) {
-        uint256 _bal = THREELBTC.balanceOf(address(this)).add(agBal());
-        uint256 _skew = skew();
-        uint256 _target = pool.longBalance() / threshold;
-        uint256 target = _target.sub(pool.shortBalance());
-        return target;
-    }
-
-    function acquiring() public view returns (uint256) {
-        uint256 _bal = THREELBTC.balanceOf(address(this)).add(agBal());
-        return target().sub(_bal);
-    }
-
-    function disposing() public view returns (uint256) {
-        uint256 _bal = THREELBTC.balanceOf(address(this)).add(agBal());
-        return _bal.sub(target());
-    }
-
-    function acquire(uint256 _amount) private {
-        bytes32 args = encoder.encodeCommitParams(
-            _amount,
-            IPoolCommitter.CommitType.LongMint,
-            agBalBool(_amount),
-            true
-        );
-        poolCommitter.commit(args);
-        emit acquired(_amount);
-        tradeLive = true;
-    }
-
-    function dispose(uint256 _amount) private {
-        bytes32 args = encoder.encodeCommitParams(
-            _amount,
-            IPoolCommitter.CommitType.LongBurn,
-            agBalBool(_amount),
-            true
-        );
-        poolCommitter.commit(args);
-        tradeLive = false;
-    }
-
-    function agBalBool(uint256 _amt) public view returns (bool) {
-        uint256 lTokens = poolCommitter.getAggregateBalance(address(this)).longTokens;
-        lTokens > _amt ? true : false;
-    }
-
-    function agBal() public view returns (uint256) {
-        uint256 lTokens = poolCommitter.getAggregateBalance(address(this)).longTokens;
-        return lTokens;
-    }
-
-    modifier onlyPlayer() {
-        require(vault.balanceOf(address(msg.sender)) > 1, "Only player can execute");
-        _;
-    }
-}
diff --git a/forge/src/test/utils/Console.sol b/forge/src/test/utils/Console.sol
deleted file mode 100644
index f5cf485..0000000
--- a/forge/src/test/utils/Console.sol
+++ /dev/null
@@ -1,3113 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity >=0.8.0;
-
-/* solhint-disable */
-library console {
-    address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);
-
-    function _sendLogPayload(bytes memory payload) private view {
-        uint256 payloadLength = payload.length;
-        address consoleAddress = CONSOLE_ADDRESS;
-        assembly {
-            let payloadStart := add(payload, 32)
-            let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
-        }
-    }
-
-    function log() internal view {
-        _sendLogPayload(abi.encodeWithSignature("log()"));
-    }
-
-    function logInt(int256 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(int)", p0));
-    }
-
-    function logUint(uint256 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
-    }
-
-    function logString(string memory p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
-    }
-
-    function logBool(bool p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
-    }
-
-    function logAddress(address p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
-    }
-
-    function logBytes(bytes memory p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
-    }
-
-    function logBytes1(bytes1 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
-    }
-
-    function logBytes2(bytes2 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
-    }
-
-    function logBytes3(bytes3 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
-    }
-
-    function logBytes4(bytes4 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
-    }
-
-    function logBytes5(bytes5 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
-    }
-
-    function logBytes6(bytes6 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
-    }
-
-    function logBytes7(bytes7 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
-    }
-
-    function logBytes8(bytes8 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
-    }
-
-    function logBytes9(bytes9 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
-    }
-
-    function logBytes10(bytes10 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
-    }
-
-    function logBytes11(bytes11 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
-    }
-
-    function logBytes12(bytes12 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
-    }
-
-    function logBytes13(bytes13 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
-    }
-
-    function logBytes14(bytes14 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
-    }
-
-    function logBytes15(bytes15 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
-    }
-
-    function logBytes16(bytes16 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
-    }
-
-    function logBytes17(bytes17 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
-    }
-
-    function logBytes18(bytes18 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
-    }
-
-    function logBytes19(bytes19 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
-    }
-
-    function logBytes20(bytes20 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
-    }
-
-    function logBytes21(bytes21 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
-    }
-
-    function logBytes22(bytes22 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
-    }
-
-    function logBytes23(bytes23 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
-    }
-
-    function logBytes24(bytes24 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
-    }
-
-    function logBytes25(bytes25 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
-    }
-
-    function logBytes26(bytes26 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
-    }
-
-    function logBytes27(bytes27 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
-    }
-
-    function logBytes28(bytes28 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
-    }
-
-    function logBytes29(bytes29 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
-    }
-
-    function logBytes30(bytes30 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
-    }
-
-    function logBytes31(bytes31 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
-    }
-
-    function logBytes32(bytes32 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
-    }
-
-    function log(bytes32[] memory p0) internal view {
-        for (uint256 i; i < p0.length; ) {
-            _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0[i]));
-            unchecked {
-                ++i;
-            }
-        }
-    }
-
-    function log(uint256 p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
-    }
-
-    function log(uint256[] memory p0) internal view {
-        for (uint256 i; i < p0.length; ) {
-            _sendLogPayload(abi.encodeWithSignature("log(uint)", p0[i]));
-            unchecked {
-                ++i;
-            }
-        }
-    }
-
-    function log(string memory p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
-    }
-
-    function log(string[] memory p0) internal view {
-        for (uint256 i; i < p0.length; ) {
-            _sendLogPayload(abi.encodeWithSignature("log(string)", p0[i]));
-            unchecked {
-                ++i;
-            }
-        }
-    }
-
-    function log(bool p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
-    }
-
-    function log(bool[] memory p0) internal view {
-        for (uint256 i; i < p0.length; ) {
-            _sendLogPayload(abi.encodeWithSignature("log(bool)", p0[i]));
-            unchecked {
-                ++i;
-            }
-        }
-    }
-
-    function log(address p0) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
-    }
-
-    function log(address[] memory p0) internal view {
-        for (uint256 i; i < p0.length; ) {
-            _sendLogPayload(abi.encodeWithSignature("log(address)", p0[i]));
-            unchecked {
-                ++i;
-            }
-        }
-    }
-
-    function log(uint256 p0, uint256 p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
-    }
-
-    function log(uint256 p0, string memory p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
-    }
-
-    function log(uint256 p0, bool p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
-    }
-
-    function log(uint256 p0, address p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
-    }
-
-    function log(string memory p0, uint256 p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
-    }
-
-    function log(string memory p0, string memory p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
-    }
-
-    function log(string memory p0, bool p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
-    }
-
-    function log(string memory p0, address p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
-    }
-
-    function log(bool p0, uint256 p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
-    }
-
-    function log(bool p0, string memory p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
-    }
-
-    function log(bool p0, bool p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
-    }
-
-    function log(bool p0, address p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
-    }
-
-    function log(address p0, uint256 p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
-    }
-
-    function log(address p0, string memory p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
-    }
-
-    function log(address p0, bool p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
-    }
-
-    function log(address p0, address p1) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        uint256 p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        string memory p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        bool p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        address p2
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        uint256 p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        string memory p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        bool p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        uint256 p0,
-        address p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        uint256 p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        string memory p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        bool p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        string memory p0,
-        address p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        uint256 p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        string memory p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        bool p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        bool p0,
-        address p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        uint256 p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        string memory p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        bool p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        uint256 p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        uint256 p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        uint256 p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        uint256 p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        string memory p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        string memory p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        string memory p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        string memory p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        bool p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        bool p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        bool p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        bool p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        address p2,
-        uint256 p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        address p2,
-        string memory p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        address p2,
-        bool p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
-    }
-
-    function log(
-        address p0,
-        address p1,
-        address p2,
-        address p3
-    ) internal view {
-        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
-    }
-}
diff --git a/forge/src/test/utils/Utilities.sol b/forge/src/test/utils/Utilities.sol
deleted file mode 100644
index 737b3cf..0000000
--- a/forge/src/test/utils/Utilities.sol
+++ /dev/null
@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: Unlicense
-pragma solidity >=0.8.0;
-
-import {DSTest} from "ds-test/test.sol";
-import {Vm} from "forge-std/Vm.sol";
-
-//common utilities for forge tests
-contract Utilities is DSTest {
-    Vm internal immutable vm = Vm(HEVM_ADDRESS);
-    bytes32 internal nextUser = keccak256(abi.encodePacked("user address"));
-
-    function getNextUserAddress() external returns (address payable) {
-        //bytes32 to address conversion
-        address payable user = payable(address(uint160(uint256(nextUser))));
-        nextUser = keccak256(abi.encodePacked(nextUser));
-        return user;
-    }
-
-    //create users with 100 ether balance
-    function createUsers(uint256 userNum) external returns (address payable[] memory) {
-        address payable[] memory users = new address payable[](userNum);
-        for (uint256 i = 0; i < userNum; i++) {
-            address payable user = this.getNextUserAddress();
-            vm.deal(user, 100 ether);
-            users[i] = user;
-        }
-        return users;
-    }
-
-    //move block.number forward by a given number of blocks
-    function mineBlocks(uint256 numBlocks) external {
-        uint256 targetBlock = block.number + numBlocks;
-        vm.roll(targetBlock);
-    }
-}
diff --git a/forge/src/test/vUSDC.t.sol b/forge/src/test/vUSDC.t.sol
deleted file mode 100644
index 35a53f0..0000000
--- a/forge/src/test/vUSDC.t.sol
+++ /dev/null
@@ -1,151 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.10;
-// disregard import failures
-import "ds-test/test.sol";
-import {vUSDC} from "../vUSDC.sol";
-import "../utils/ERC20TokenFaker.sol";
-import "../utils/FakeERC20.sol";
-import "./utils/Utilities.sol";
-import {ERC20, ERC4626} from "solmate/mixins/ERC4626.sol";
-import "openzeppelin/utils/Strings.sol";
-import {IStargate} from "../interfaces/IStargate.sol";
-
-/// @title A Test for vUSDC
-/// @author koda
-/// @notice This test relies on FakeERC20.sol to test USDC deposits and staking
-/// @notice Utilities.sol provides some useful functions for creating users
-/// @notice VM is the cheatcode reference. eg. vm.warp(1 days) warps timestamp forward 1 day
-/// @dev Some tests require changes to origional contact (eg. LPTest)
-
-contract vUSDCtest is DSTest, ERC20TokenFaker {
-    vUSDC vusd;
-    FakeERC20 fakeUSDC;
-    ERC20 UNDERLYING;
-    FakeERC20 fakeSTG;
-    Utilities internal utils;
-    address payable[] internal users;
-    Vm internal immutable vm = Vm(HEVM_ADDRESS);
-
-    // Vm constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
-
-    function setUp() public {
-        fakeUSDC = fakeOutERC20(address(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8));
-        fakeUSDC._setBalance(address(this), 1e18);
-        vusd = new vUSDC(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8, "vault", "vlt");
-        vusd.setFee(10);
-        vusd.setFeeCollector(address((this)));
-        ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).approve(
-            address(vusd),
-            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-        );
-        ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(
-            address(this),
-            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-        );
-        ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(
-            address(vusd),
-            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-        );
-        ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e).approve(
-            0xeA8DfEE1898a7e0a59f7527F076106d7e44c2176,
-            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-        );
-        ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(
-            address(vusd),
-            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-        );
-        ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(
-            address(this),
-            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-        );
-        ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).approve(
-            0x53Bf833A5d6c4ddA888F69c22C88C9f356a41614,
-            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-        );
-        vusd.deposit(1000000000, address(this));
-        utils = new Utilities();
-        users = utils.createUsers(5);
-    }
-
-    function setFeeFail() public {
-        address payable alice = users[0];
-        vm.prank(alice);
-        vusd.setFee(100);
-        vm.expectRevert();
-        assert(vusd.fee() == 0);
-    }
-
-    function testInitialBalance() public {
-        assertEq(1000000000, vusd.balanceOf(address(this)));
-    }
-
-    function testUserDeposit() public {
-        address payable alice = users[0];
-        vm.label(alice, "Alice");
-        assertEq(0, vusd.balanceOf(alice));
-        vusd.deposit(1000000000, alice);
-        assert(vusd.balanceOf(alice) > 1);
-    }
-
-    // // test whole deposit flow
-    function testDeposit() public {
-        uint256 bal = vusd.balanceOf(address(this));
-        vusd.deposit(1000000, address(this));
-        //  assert(vusd.balanceOf(address(this)) > 1);
-        assert(vusd.balanceOf(address(this)) > bal);
-        emit log("deposit");
-    }
-
-    // function testDepositCompound() public {
-    //     fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
-    //     fakeSTG._setBalance(address(vusd), 1e18);
-    //     vm.warp(2 days);
-    //     vusd.deposit(100000, address(this));
-    // }
-
-    // test just reciept of LP tokens (comment out stake)
-    // function testLP() public {
-    //     ERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48).approve(address(vusd), 10000000000000);
-    //     vusd.approve(address(vusd), 10000000000000);
-    //     ERC20(0xdf0770dF86a8034b3EFEf0A1Bb3c889B8332FF56).approve(address(vusd), 10000000000000);
-    //     vusd.deposit(100000000, address(this));
-    //     assert(ERC20(0xdf0770dF86a8034b3EFEf0A1Bb3c889B8332FF56).balanceOf(address(vusd)) >= 1);
-    // }
-    // // test reciept of stg tokens on deposit fast forward
-    // function testRewards() public {
-    //     vusd.deposit(1000000000000, address(this));
-    //     vusd.stake();
-    //     vm.warp(1 days);
-    //     vusd.deposit(1000, address(this));
-    //     vusd.stake();
-    //    assert(ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6).balanceOf(address(vusd)) > 0);
-    // }
-    //change withdraw logic so assets are representing staked balance
-    function testWithdraw() public {
-        vusd.withdraw(1000000, address(this), address(this));
-        emit log("withdraw");
-    }
-
-    function testLPStats() public {
-        assert(vusd.lpStats() > 0);
-    }
-
-    function testCompound() public {
-        fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
-        fakeSTG._setBalance(address(vusd), 1e18);
-        uint256 _pb = vusd.value();
-        vusd.compound();
-        uint256 _nb = vusd.value();
-        assert(_nb > _pb);
-    }
-
-    function testCompoundWithFee() public {
-        vusd.setFee(10000);
-        fakeSTG = fakeOutERC20(address(0x6694340fc020c5E6B96567843da2df01b2CE1eb6));
-        fakeSTG._setBalance(address(vusd), 1e18);
-        uint256 _pb = vusd.value();
-        vusd.compound();
-        uint256 _nb = vusd.value();
-        assert(_nb > _pb);
-    }
-}
diff --git a/forge/src/utils/ERC20TokenFaker.sol b/forge/src/utils/ERC20TokenFaker.sol
deleted file mode 100644
index f034e53..0000000
--- a/forge/src/utils/ERC20TokenFaker.sol
+++ /dev/null
@@ -1,39 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity 0.8.10;
-
-import "./IVM.sol";
-import "./FakeERC20.sol";
-
-abstract contract ERC20TokenFaker {
-    FakeERC20 FAKE = new FakeERC20();
-    IVm VM = IVm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
-
-    function fakeOutERC20(address token) internal returns (FakeERC20 fakedToken) {
-        fakeOut(token, address(FAKE).code);
-        fakedToken = FakeERC20(payable(token));
-    }
-
-    function unfakeERC20(address token) internal {
-        unfake(token);
-    }
-
-    function fakeOut(address orig, bytes memory code) private {
-        // Move the original code to a new address
-        address moved = movedAddress(orig);
-        VM.etch(moved, orig.code);
-
-        // Replace code with faked implementation
-        VM.etch(orig, code);
-    }
-
-    function unfake(address addr) private {
-        address moved = movedAddress(addr);
-        if (addr.code.length != 0) {
-            VM.etch(addr, moved.code);
-        }
-    }
-
-    function movedAddress(address orig) private returns (address moved) {
-        moved = address(uint160(address(orig)) + 1);
-    }
-}
diff --git a/forge/src/utils/FakeERC20.sol b/forge/src/utils/FakeERC20.sol
deleted file mode 100644
index dda6554..0000000
--- a/forge/src/utils/FakeERC20.sol
+++ /dev/null
@@ -1,225 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.10;
-
-interface IERC20 {
-    function allowance(address owner, address spender) external returns (uint256);
-
-    function balanceOf(address owner) external returns (uint256);
-}
-
-contract FakeERC20 {
-    struct ShadowedAmount {
-        bool isShadowed;
-        uint256 lastTrueAmount;
-        uint256 shadowedAmount;
-    }
-
-    struct Storage {
-        mapping(address => ShadowedAmount) shadowedBalances;
-        mapping(address => mapping(address => ShadowedAmount)) shadowedAllowances;
-    }
-
-    bytes32 private constant STORAGE_SLOT = 0x64fd48372774b9637ace5c8c7a951f04ea13c793935207f2eada5382a0ec82cb;
-
-    receive() external payable {}
-
-    fallback() external payable {
-        bytes memory r = _forwardCallToImpl();
-        assembly {
-            return(add(r, 32), mload(r))
-        }
-    }
-
-    function balanceOf(address owner)
-        external
-        returns (
-            /* view */
-            uint256 balance
-        )
-    {
-        ShadowedAmount memory sBal = _getSyncedBalance(owner);
-        return sBal.shadowedAmount;
-    }
-
-    function allowance(address owner, address spender)
-        external
-        returns (
-            /* view */
-            uint256 allowance_
-        )
-    {
-        ShadowedAmount memory sBal = _getSyncedAllowance(owner, spender);
-        return sBal.shadowedAmount;
-    }
-
-    function transferFrom(
-        address from,
-        address to,
-        uint256 amount
-    ) public returns (bool success) {
-        _updateAllowance(from, amount);
-        success = _transferFromInternal(from, to, amount);
-    }
-
-    function transfer(address to, uint256 amount) external returns (bool success) {
-        success = _transferFromInternal(msg.sender, to, amount);
-    }
-
-    function approve(address spender, uint256 amount) external returns (bool) {
-        ShadowedAmount memory sAllowance = _getSyncedAllowance(msg.sender, spender);
-
-        sAllowance.shadowedAmount = amount;
-        _writeSyncedAllowance(msg.sender, spender, sAllowance);
-
-        return true;
-    }
-
-    function _setBalance(address owner, uint256 amount) public returns (uint256 newBalance) {
-        ShadowedAmount memory sBal = _getSyncedBalance(owner);
-        sBal.shadowedAmount = amount;
-        _writeSyncedBalance(owner, sBal);
-        newBalance = _getStorage().shadowedBalances[owner].shadowedAmount;
-    }
-
-    function _getSyncedAllowance(address owner, address spender)
-        private
-        returns (
-            /* view */
-            ShadowedAmount memory sAllowance
-        )
-    {
-        uint256 trueAmount = abi.decode(
-            _forwardCallToImpl(abi.encodeWithSelector(IERC20.allowance.selector, owner, spender)),
-            (uint256)
-        );
-        // We only want to measure the cost of the underlying token storage lookup
-        // Not including the excess overhead of our shadow lookup
-        sAllowance = _getStorage().shadowedAllowances[owner][spender];
-        _syncShadowedAmount(sAllowance, trueAmount);
-    }
-
-    function _getSyncedBalance(address owner) private returns (ShadowedAmount memory sBal) {
-        uint256 trueAmount = abi.decode(
-            _forwardCallToImpl(abi.encodeWithSelector(IERC20.balanceOf.selector, owner)),
-            (uint256)
-        );
-        // We only want to measure the cost of the underlying token storage lookup
-        // Not including the excess overhead of our shadow lookup
-        sBal = _getStorage().shadowedBalances[owner];
-        _syncShadowedAmount(sBal, trueAmount);
-    }
-
-    function _syncShadowedAmount(ShadowedAmount memory sAmount, uint256 trueAmount) private pure {
-        if (!sAmount.isShadowed) {
-            sAmount.isShadowed = true;
-            sAmount.shadowedAmount = trueAmount;
-        } else {
-            // Detect balance changes that can occur from outside of ERC20
-            // functions.
-            if (sAmount.lastTrueAmount > trueAmount) {
-                sAmount.shadowedAmount = _sub(
-                    sAmount.lastTrueAmount,
-                    sAmount.lastTrueAmount - trueAmount,
-                    "FakeERC20/SHADOW_ADJUSTMENT_UNDERFLOW"
-                );
-            } else if (sAmount.lastTrueAmount < trueAmount) {
-                sAmount.shadowedAmount = _add(
-                    sAmount.lastTrueAmount,
-                    trueAmount - sAmount.lastTrueAmount,
-                    "FakeERC20/SHADOW_ADJUSTMENT_OVERFLOW"
-                );
-            }
-        }
-        sAmount.lastTrueAmount = trueAmount;
-    }
-
-    function _writeSyncedBalance(address owner, ShadowedAmount memory sBal) private {
-        _getStorage().shadowedBalances[owner] = sBal;
-    }
-
-    function _writeSyncedAllowance(
-        address owner,
-        address spender,
-        ShadowedAmount memory sAllowance
-    ) private {
-        _getStorage().shadowedAllowances[owner][spender] = sAllowance;
-    }
-
-    function _getStorage() private pure returns (Storage storage st) {
-        bytes32 slot = STORAGE_SLOT;
-        assembly {
-            st.slot := slot
-        }
-    }
-
-    function _getOriginalImplementationAddress() private view returns (address impl) {
-        return address(uint160(address(this)) + 1);
-    }
-
-    function _forwardCallToImpl() private returns (bytes memory resultData) {
-        bool success;
-        (success, resultData) = _getOriginalImplementationAddress().delegatecall(msg.data);
-        if (!success) {
-            assembly {
-                revert(add(resultData, 32), mload(resultData))
-            }
-        }
-    }
-
-    function _forwardCallToImpl(bytes memory callData) private returns (bytes memory resultData) {
-        bool success;
-        (success, resultData) = _getOriginalImplementationAddress().delegatecall(callData);
-        if (!success) {
-            assembly {
-                revert(add(resultData, 32), mload(resultData))
-            }
-        }
-    }
-
-    function _transferFromInternal(
-        address from,
-        address to,
-        uint256 amount
-    ) internal returns (bool) {
-        ShadowedAmount memory sFromBal;
-        ShadowedAmount memory sToBal;
-
-        sFromBal = _getSyncedBalance(from);
-        sFromBal.shadowedAmount = _sub(sFromBal.shadowedAmount, amount, "FakeERC20/BALANCE_UNDERFLOW");
-        _writeSyncedBalance(from, sFromBal);
-
-        sToBal = _getSyncedBalance(to);
-        sToBal.shadowedAmount = _add(sToBal.shadowedAmount, amount, "FakeERC20/BALANCE_OVERFLOW");
-        _writeSyncedBalance(to, sToBal);
-
-        return true;
-    }
-
-    function _updateAllowance(address from, uint256 amount) internal {
-        ShadowedAmount memory sAllowance = _getSyncedAllowance(from, msg.sender);
-        if (from != msg.sender && sAllowance.shadowedAmount != type(uint256).max) {
-            sAllowance.shadowedAmount = _sub(sAllowance.shadowedAmount, amount, "FakeERC20/ALLOWANCE_UNDERFLOW");
-            _writeSyncedAllowance(from, msg.sender, sAllowance);
-        }
-        // Assume a NON MAX_UINT results in allowance update SSTORE
-        _writeSyncedAllowance(from, msg.sender, sAllowance);
-    }
-
-    function _add(
-        uint256 a,
-        uint256 b,
-        string memory errMsg
-    ) private pure returns (uint256 c) {
-        c = a + b;
-        require(c >= a, errMsg);
-    }
-
-    function _sub(
-        uint256 a,
-        uint256 b,
-        string memory errMsg
-    ) private pure returns (uint256 c) {
-        c = a - b;
-        require(c <= a, errMsg);
-    }
-}
diff --git a/forge/src/utils/IVm.sol b/forge/src/utils/IVm.sol
deleted file mode 100644
index efc5472..0000000
--- a/forge/src/utils/IVm.sol
+++ /dev/null
@@ -1,99 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity 0.8.10;
-
-interface IVm {
-    // Set block.timestamp
-    function warp(uint256) external;
-
-    // Set block.number
-    function roll(uint256) external;
-
-    // Set block.basefee
-    function fee(uint256) external;
-
-    // Loads a storage slot from an address
-    function load(address account, bytes32 slot) external returns (bytes32);
-
-    // Stores a value to an address' storage slot
-    function store(
-        address account,
-        bytes32 slot,
-        bytes32 value
-    ) external;
-
-    // Signs data
-    function sign(uint256 privateKey, bytes32 digest)
-        external
-        returns (
-            uint8 v,
-            bytes32 r,
-            bytes32 s
-        );
-
-    // Computes address for a given private key
-    function addr(uint256 privateKey) external returns (address);
-
-    // Performs a foreign function call via terminal
-    function ffi(string[] calldata) external returns (bytes memory);
-
-    // Sets the *next* call's msg.sender to be the input address
-    function prank(address) external;
-
-    // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
-    function startPrank(address) external;
-
-    // Sets the *next* call's msg.sender to be the input address, and the tx.origin to be the second input
-    function prank(address, address) external;
-
-    // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called, and the tx.origin to be the second input
-    function startPrank(address, address) external;
-
-    // Resets subsequent calls' msg.sender to be `address(this)`
-    function stopPrank() external;
-
-    // Sets an address' balance
-    function deal(address who, uint256 newBalance) external;
-
-    // Sets an address' code
-    function etch(address who, bytes calldata code) external;
-
-    // Expects an error on next call
-    function expectRevert(bytes calldata) external;
-
-    function expectRevert(bytes4) external;
-
-    // Record all storage reads and writes
-    function record() external;
-
-    // Gets all accessed reads and write slot from a recording session, for a given address
-    function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
-
-    // Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData).
-    // Call this function, then emit an event, then call a function. Internally after the call, we check if
-    // logs were emitted in the expected order with the expected topics and data (as specified by the booleans)
-    function expectEmit(
-        bool,
-        bool,
-        bool,
-        bool
-    ) external;
-
-    // Mocks a call to an address, returning specified data.
-    // Calldata can either be strict or a partial match, e.g. if you only
-    // pass a Solidity selector to the expected calldata, then the entire Solidity
-    // function will be mocked.
-    function mockCall(
-        address,
-        bytes calldata,
-        bytes calldata
-    ) external;
-
-    // Clears all mocked calls
-    function clearMockedCalls() external;
-
-    // Expect a call to an address with the specified calldata.
-    // Calldata can either be strict or a partial match
-    function expectCall(address, bytes calldata) external;
-
-    function getCode(string calldata) external returns (bytes memory);
-}
diff --git a/forge/src/utils/L2Encoder.sol b/forge/src/utils/L2Encoder.sol
deleted file mode 100644
index 3959579..0000000
--- a/forge/src/utils/L2Encoder.sol
+++ /dev/null
@@ -1,57 +0,0 @@
-//SPDX-License-Identifier: CC-BY-NC-ND-4.0
-pragma solidity 0.8.7;
-
-import {SafeCast} from "openzeppelin/utils/math/SafeCast.sol";
-import "../interfaces/IPoolCommitter.sol";
-
-/**
- * @title L2Encoder
- * @notice Helper contract to encode calldata, used to optimize calldata size
- * only indented to help generate calldata for uses/frontends.
- */
-contract L2Encoder {
-    using SafeCast for uint256;
-
-    /**
-     * @notice Encodes an array of addresses to compact representation as a bytes array
-     * @param args The array of LeveragedPool addresses to perform upkeep on
-     * @return compact bytes array of addresses
-     */
-    function encodeAddressArray(address[] calldata args) external pure returns (bytes memory) {
-        bytes memory encoded;
-        uint256 len = args.length;
-        for (uint256 i = 0; i < len; i++) {
-            encoded = bytes.concat(encoded, abi.encodePacked(args[i]));
-        }
-        return encoded;
-    }
-
-    /**
-     * @notice Encodes commit parameters from standard input to compact representation of 1 bytes32
-     * @param amount Amount of settlement tokens you want to commit to minting; OR amount of pool
-     *               tokens you want to burn
-     * @param commitType Type of commit you're doing (Long vs Short, Mint vs Burn)
-     * @param fromAggregateBalance If minting, burning, or rebalancing into a delta neutral position,
-     *                             will tokens be taken from user's aggregate balance?
-     * @param payForClaim True if user wants to pay for the commit to be claimed
-     * @return compact representation of commit parameters
-     */
-    function encodeCommitParams(
-        uint256 amount,
-        IPoolCommitter.CommitType commitType,
-        bool fromAggregateBalance,
-        bool payForClaim
-    ) external pure returns (bytes32) {
-        uint128 shortenedAmount = amount.toUint128();
-
-        bytes32 res;
-
-        assembly {
-            res := add(
-                shortenedAmount,
-                add(shl(128, commitType), add(shl(136, fromAggregateBalance), shl(144, payForClaim)))
-            )
-        }
-        return res;
-    }
-}
diff --git a/forge/src/vUSDC.sol b/forge/src/vUSDC.sol
deleted file mode 100644
index 5485299..0000000
--- a/forge/src/vUSDC.sol
+++ /dev/null
@@ -1,155 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.10;
-import "solmate/mixins/ERC4626.sol";
-import {ERC20} from "solmate/tokens/ERC20.sol";
-import {IStargate} from "./interfaces/IStargate.sol";
-import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";
-import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
-import {Ownable} from "openzeppelin/access/Ownable.sol";
-import {IRouter} from "./interfaces/IRouter.sol";
-import {IAsset, IBalancer} from "./interfaces/IBalancer.sol";
-import {IERC20} from "openzeppelin/token/ERC20/IERC20.sol";
-
-/// @title Vault for USDC stargate staking and compounding for more USDC
-/// @author koda
-/// @notice This contract is initialised with variables for the Arbitrum network
-/// @notice This contract passes all tests on ETH mainnet when substitued with mainnet variables
-/// @dev Gas optimisation is not implemented
-contract vUSDC is ERC4626, Ownable {
-    using FixedPointMathLib for uint256;
-    event balancerSwap(uint256 _amt);
-    event staked(uint256 _amt);
-    event stgBal(uint256 _stgBal);
-    event feeCollected(uint256 _amt);
-    event Log(string message);
-
-    //usdc
-    ERC20 public immutable UNDERLYING;
-    //pUSDC
-    ERC20 public immutable POOLTOKEN;
-    //stg token
-    ERC20 public STG;
-    //stg contract, import interface
-    IStargate public staker;
-    //fee collector
-    address public feeCollector;
-    //stargate pool ID (usd = 1)
-    //router
-    IRouter public immutable router;
-    //deposit fee
-    uint256 public fee;
-    bytes32 public immutable _balancerPool = 0x3a4c6d2404b5eb14915041e01f63200a82f4a343000200000000000000000065; //arbitrum balancer vault
-
-    constructor(
-        address _underlying,
-        string memory name,
-        string memory symbol
-    ) ERC4626(ERC20(_underlying), name, symbol) {
-        UNDERLYING = ERC20(_underlying);
-        router = IRouter(0x53Bf833A5d6c4ddA888F69c22C88C9f356a41614); //arbitrum router
-        staker = IStargate(0xeA8DfEE1898a7e0a59f7527F076106d7e44c2176); //Arbitrum LP staker
-        POOLTOKEN = ERC20(0x892785f33CdeE22A30AEF750F285E18c18040c3e); //Arbitrum USDC LP token
-        STG = ERC20(0x6694340fc020c5E6B96567843da2df01b2CE1eb6); //Arbitrum STG reward token
-        UNDERLYING.approve(address(router), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
-        POOLTOKEN.approve(address(staker), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
-        STG.approve(
-            0xBA12222222228d8Ba445958a75a0704d566BF2C8,
-            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-        );
-        STG.approve(
-            0xeA8DfEE1898a7e0a59f7527F076106d7e44c2176,
-            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-        );
-    }
-
-    function totalAssets() public view virtual override returns (uint256) {
-        return value();
-    }
-
-    // $ per LP token
-    function lpStats() public view virtual returns (uint256) {
-        uint256 sup = POOLTOKEN.totalSupply();
-        uint256 bal = UNDERLYING.balanceOf(address(POOLTOKEN));
-        return bal.divWadDown(sup);
-    }
-
-    function value() public view returns (uint256) {
-        (uint256 amount, ) = staker.userInfo(0, address(this));
-        return amount.mulWadDown(lpStats());
-    }
-
-    function lpPerShare() public view returns (uint256) {
-        (uint256 amount, ) = staker.userInfo(0, address(this));
-        return amount.divWadDown(totalSupply);
-    }
-
-    function afterDeposit(uint256 assets, uint256 shares) internal virtual override {
-        router.addLiquidity(1, assets, address(this));
-        stake();
-    }
-
-    function stake() internal {
-        uint256 _bal = POOLTOKEN.balanceOf(address(this));
-        staker.deposit(0, _bal);
-    }
-
-    function beforeWithdraw(uint256 assets, uint256 shares) internal virtual override {
-        uint256 lpWant = lpPerShare().mulWadDown(shares);
-        IStargate(staker).withdraw(0, lpWant);
-        router.instantRedeemLocal(1, lpWant, address(this));
-        require(UNDERLYING.balanceOf(address(this)) > 0, "no underlying");
-    }
-
-    function assetsToLp(uint256 assets) public view returns (uint256) {
-        return assets.divWadDown(lpStats());
-    }
-
-    function setFee(uint256 _fee) public onlyOwner {
-        fee = _fee;
-    }
-
-    function setStaker(address _staker) public onlyOwner {
-        staker = IStargate(_staker);
-    }
-
-    function setFeeCollector(address _feeCollector) public onlyOwner {
-        feeCollector = _feeCollector;
-    }
-
-    //swap on balancer stg for more USDC, add liquidity, stake.
-    function compound() public onlyOwner {
-        uint256 _stg = STG.balanceOf(address(this));
-        if (_stg > 1) {
-            IBalancer.SingleSwap memory swapParams = IBalancer.SingleSwap({
-                poolId: _balancerPool,
-                kind: IBalancer.SwapKind.GIVEN_IN,
-                assetIn: IAsset(0x6694340fc020c5E6B96567843da2df01b2CE1eb6),
-                assetOut: IAsset(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8),
-                amount: _stg,
-                userData: "0x"
-            });
-            IBalancer.FundManagement memory funds = IBalancer.FundManagement({
-                sender: address(this),
-                recipient: payable(address(this)),
-                fromInternalBalance: false,
-                toInternalBalance: false
-            });
-            // perform swap
-            IBalancer(0xBA12222222228d8Ba445958a75a0704d566BF2C8).swap(swapParams, funds, 1, block.timestamp + 60);
-            emit balancerSwap(_stg);
-            uint256 _underlying = ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).balanceOf(address(this));
-            if (fee > 0) {
-                uint256 _fee = _underlying.mulWadDown(fee);
-                ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).transfer(feeCollector, _fee);
-                emit feeCollected(_fee);
-            }
-            uint256 underlying = ERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).balanceOf(address(this));
-            // Deposit stablecoin liquidity
-            router.addLiquidity(1, underlying, address(this));
-            stake();
-            emit staked(underlying);
-            emit Log("compounded");
-        }
-        return;
-    }
-}
diff --git a/lib/openzeppelin-contracts b/lib/openzeppelin-contracts
new file mode 160000
index 0000000..5a75065
--- /dev/null
+++ b/lib/openzeppelin-contracts
@@ -0,0 +1 @@
+Subproject commit 5a75065659a65e65bb04890192e3a4bcb7917fff
diff --git a/lib/solmate b/lib/solmate
index e7deddf..9f16db2 160000
--- a/lib/solmate
+++ b/lib/solmate
@@ -1 +1 @@
-Subproject commit e7deddffd5206cdec1d554c5361f529c2a525846
+Subproject commit 9f16db2144cc9a7e2ffc5588d4bf0b66784283bd

From 252d9c32308691f336eed423eca3356e3c8628b7 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 13:46:00 +1000
Subject: [PATCH 14/45] git submodule -OZ

---
 .gitmodules | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitmodules b/.gitmodules
index ff203b4..7a703c9 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -19,3 +19,6 @@
 [submodule "forge/lib/forge-std"]
 	path = forge/lib/forge-std
 	url = https://github.com/brockelmore/forge-std
+[submodule "lib/openzeppelin-contracts"]
+	path = lib/openzeppelin-contracts
+	url = https://github.com/openzeppelin/openzeppelin-contracts

From 82beaedb8f5b3849121c6d026cd94c9238b78bd9 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 15:04:28 +1000
Subject: [PATCH 15/45] forge install: perpetual-pools-contracts

---
 .gitmodules                   | 3 +++
 lib/perpetual-pools-contracts | 1 +
 2 files changed, 4 insertions(+)
 create mode 160000 lib/perpetual-pools-contracts

diff --git a/.gitmodules b/.gitmodules
index 7a703c9..e985ad5 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -22,3 +22,6 @@
 [submodule "lib/openzeppelin-contracts"]
 	path = lib/openzeppelin-contracts
 	url = https://github.com/openzeppelin/openzeppelin-contracts
+[submodule "lib/perpetual-pools-contracts"]
+	path = lib/perpetual-pools-contracts
+	url = https://github.com/tracer-protocol/perpetual-pools-contracts
diff --git a/lib/perpetual-pools-contracts b/lib/perpetual-pools-contracts
new file mode 160000
index 0000000..40a70d5
--- /dev/null
+++ b/lib/perpetual-pools-contracts
@@ -0,0 +1 @@
+Subproject commit 40a70d5a33749a1e6a4094c8270a58406ee1026d

From f874d8c126ab9903bbe379f8e5af24930cc01061 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 15:51:48 +1000
Subject: [PATCH 16/45] add poke function, add tradingStats, clean libs

---
 contracts/LongSkewVault.sol   | 173 ++++++++++++++++++++++++----------
 contracts/utils/L2Encoder.sol |   2 +-
 2 files changed, 126 insertions(+), 49 deletions(-)

diff --git a/contracts/LongSkewVault.sol b/contracts/LongSkewVault.sol
index 269adef..fa27ba0 100644
--- a/contracts/LongSkewVault.sol
+++ b/contracts/LongSkewVault.sol
@@ -4,30 +4,40 @@ import {ILeveragedPool} from "./interfaces/tracer/ILeveragedPool.sol";
 import {L2Encoder} from "./utils/L2Encoder.sol";
 import {IPoolCommitter} from "./interfaces/tracer/IPoolCommitter.sol";
 import {ERC20} from "../lib/solmate/src/tokens/ERC20.sol";
+import {SafeMath} from "../lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol";
+
+// import {PoolCommitter} from "../lib/perpetual-pools-contracts/contracts/implementation/PoolCommitter.sol";
 
 contract LongSkewVault {
+    using SafeMath for uint256;
     enum State {
         // The vault is not active
         Inactive,
         // The vault is active
-        Active,
-        // The vault is paused
-        Paused
+        Active
     }
-    struct Active {
+    //in its active state, the vault stores the following data for managing positions
+    struct TradingStats {
         uint256 startTime;
         uint256 startSkew;
+        uint256 previousPrice;
         uint256 targetAmt;
+        bool swapping;
+        bool unWinding;
         uint256 amtLong;
+        uint256 want;
     }
-
+    State state;
+    TradingStats tradingStats; // only used in Active state
     ERC20 USDC;
+    ERC20 longToken;
     ERC20 THREELBTC;
     IPoolCommitter poolCommitter;
     ERC20 vault;
     address poolAddress;
     bool public tradeLive;
     uint256 public threshold;
+    uint256 window;
     ILeveragedPool public pool;
     L2Encoder encoder;
     event holding(uint256 _amt);
@@ -53,76 +63,143 @@ contract LongSkewVault {
         _vault = vault;
     }
 
-    function checkSkew() public onlyPlayer {
+    /**
+     * @notice Pokes the vault to conduct skew checks and update wants
+     * @dev if skew exists and the vault is active, tradingStats gets updated to reflect wants, enable swaps
+     * @dev if skew ceases to exist, tradingStats gets updated to reflect unwinding and block swaps
+     */
+    function poke() public returns (bool) {
+        require(window < block.timestamp, "poke can only be called hourly");
+        uint256 rate = tradingStats.previousPrice.div(longTokenPrice());
+        uint256 _nextPrice = tradingStats.previousPrice.mul(rate);
+        uint256 _previousPrice = tradingStats.previousPrice;
         uint256 _skew = skew();
-        uint256 _bal = THREELBTC.balanceOf(address(this)); //todo  add aggregate balance
-        if (_skew > threshold) {
-            // TODO: and skew impact
-            uint256 _target = target();
-
-            if (_bal < _target) {
-                uint256 aq = acquiring();
-                acquire(aq);
-            }
-            if (_bal > _target) {
-                uint256 ds = disposing();
-                dispose(ds);
-            }
-            if (_bal == _target) {
-                emit holding(_bal);
-            }
-            emit noAction(_skew);
+        if (_skew > threshold && state != State.Active) {
+            state = State.Active;
+            tradingStats.startSkew = _skew;
+            tradingStats.startTime = block.timestamp;
+            uint256 _target = target(rate);
+            tradingStats.targetAmt = _target;
+            tradingStats.swapping = true;
+            return true;
         }
-        if (_skew < threshold) {
-            // TODO: check if this is correct
-            dispose(_bal);
-            emit unwind(_bal);
+        if (state == State.Active && _skew > threshold && tradingStats.amtLong > 0) {
+            uint256 _amtLong = tradingStats.amtLong;
+            uint256 _target = target(rate);
+            uint256 _want = _target.sub(_amtLong);
+            tradingStats.want = _want;
+            tradingStats.swapping = true;
+            return true;
         }
+        if (threshold < _skew) {
+            uint256 balance = longToken.balanceOf(address(this)).add(
+                poolCommitter.getAggregateBalance(address(this)).longTokens
+            );
+            bytes32 args = encoder.encodeCommitParams(balance, IPoolCommitter.CommitType.LongBurn, false, true);
+            poolCommitter.commit(args);
+            emit unwind(balance);
+            tradingStats.unWinding = true;
+            tradingStats.swapping = false;
+            return false;
+        }
+        emit Log("pokey pokey");
+        window = block.timestamp + 3600;
+        tradingStats.amtLong = longToken.balanceOf(address(this)).add(
+            poolCommitter.getAggregateBalance(address(this)).longTokens
+        );
+        tradingStats.previousPrice = longTokenPrice();
     }
 
+    /**
+     * @notice Gets the current pool skew
+     * @dev returns skew
+     */
     function skew() public view returns (uint256) {
         uint256 _skew = pool.shortBalance() / pool.longBalance();
         return _skew;
     }
 
-    function target() public view returns (uint256) {
-        //todo and add aggregate Balance + forecast 8 hour window
-        uint256 _bal = THREELBTC.balanceOf(address(this));
-        uint256 _skew = _bal / skew();
-        uint256 _target = _skew - pool.longBalance();
+    /**
+     * @notice Gets the target value of wants for the vault to bring skew back to 1
+     * @param _rate rate of change of long token from previous price
+     */
+    function target(uint256 _rate) public view returns (uint256) {
+        uint256 _shortBal = pool.shortBalance().mul(1 - _rate);
+        uint256 _LongBal = pool.longBalance().mul(_rate);
+        uint256 _skew = _shortBal / _LongBal;
+        uint256 _t = _shortBal / _skew;
+        uint256 _target = _t - _LongBal;
         return _target;
     }
 
-    function acquiring() public view returns (uint256) {
-        uint256 _bal = THREELBTC.balanceOf(address(this));
-        return target() - _bal;
-    }
-
-    function disposing() public view returns (uint256) {
-        uint256 _bal = THREELBTC.balanceOf(address(this));
-        return _bal - target();
-    }
-
-    function acquire(uint256 _amount) private {
+    /**
+     * @notice Aquires long tokens for the vault from the poolCommitter
+     * @dev only call when swaps cant fulfil wants
+     * @param _amount amount of long tokens to be aquired
+     */
+    function acquire(uint256 _amount) public onlyPlayer {
+        require(state == State.Active, "vault must be active to acquire");
+        require(tradingStats.unWinding == false, "vault must be aquiring not unwinding");
+        tradingStats.swapping = false;
+        tradeLive = true;
         bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongMint, agBal(_amount), true);
         poolCommitter.commit(args);
         emit acquired(_amount);
-        tradeLive = true;
+        tradingStats.amtLong = tradingStats.amtLong.add(_amount);
+        tradingStats.want = tradingStats.want.sub(_amount);
     }
 
-    function dispose(uint256 _amount) private {
+    function agBal(uint256 _amt) public view returns (bool) {
+        uint256 lTokens = poolCommitter.getAggregateBalance(address(this)).longTokens;
+        lTokens > _amt ? true : false;
+    }
+
+    /**
+     * @notice Releases long tokens to the poolCommitter
+     * @dev only call when forcing disposal of long tokens
+     * @param _amount amount of long tokens to be released
+     * @dev must be set as role based access when in production
+     */
+    function dispose(uint256 _amount) public onlyPlayer {
+        require(state == State.Active, "vault must be active to acquire");
         bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongBurn, agBal(_amount), true);
         poolCommitter.commit(args);
         tradeLive = false;
     }
 
-    function agBal(uint256 _amt) public view returns (bool) {
-        uint256 lTokens = poolCommitter.getAggregateBalance(address(this)).longTokens;
-        lTokens > _amt ? true : false;
+    /**
+     * @notice swap function allowing users to swap longTokens for USDC
+     * @dev MUST revert when not skewed
+     * @param _amtLong long tokens to be swapped
+     * @param _minAmtUSDC minimum amount of USDC to recieve
+     */
+    function _swap(uint256 _amtLong, uint256 _minAmtUSDC) public onlyWhenSkewed returns (uint256) {
+        require(state == State.Active, "Vault is not active");
+        require(tradingStats.unWinding == false, "Vault is unwinding");
+        require(tradingStats.swapping == true, "Vault is not swapping");
+        longToken.transfer(address(this), _amtLong);
+        uint256 _out = longTokenPrice().mul(_amtLong);
+        USDC.transfer(msg.sender, _out);
+        require(_out > _minAmtUSDC, "Not enough USDC");
+        return _out;
+    }
+
+    /**
+     * @notice getter for long token price
+     */
+    function longTokenPrice() public view returns (uint256) {
+        uint256 bal = pool.longBalance();
+        uint256 price = bal.div(longToken.totalSupply());
+        return price;
     }
 
     modifier onlyPlayer() {
         require(vault.balanceOf(address(msg.sender)) > 1, "Only player can execute");
         _;
     }
+
+    modifier onlyWhenSkewed() {
+        require(skew() > threshold, "only swap when skewed");
+        _;
+    }
 }
diff --git a/contracts/utils/L2Encoder.sol b/contracts/utils/L2Encoder.sol
index 938bff8..dcbc155 100644
--- a/contracts/utils/L2Encoder.sol
+++ b/contracts/utils/L2Encoder.sol
@@ -1,7 +1,7 @@
 //SPDX-License-Identifier: CC-BY-NC-ND-4.0
 pragma solidity ^0.8.5;
 
-import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import {SafeCast} from "../../lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol";
 import "../interfaces/tracer/IPoolCommitter.sol";
 
 /**

From 7764a3e272aa023ba9ffeae1c985a9bb361dbd9b Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 15:59:02 +1000
Subject: [PATCH 17/45] clean and comment

---
 contracts/LongSkewVault.sol | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/contracts/LongSkewVault.sol b/contracts/LongSkewVault.sol
index fa27ba0..6c81835 100644
--- a/contracts/LongSkewVault.sol
+++ b/contracts/LongSkewVault.sol
@@ -6,8 +6,12 @@ import {IPoolCommitter} from "./interfaces/tracer/IPoolCommitter.sol";
 import {ERC20} from "../lib/solmate/src/tokens/ERC20.sol";
 import {SafeMath} from "../lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol";
 
-// import {PoolCommitter} from "../lib/perpetual-pools-contracts/contracts/implementation/PoolCommitter.sol";
-
+/**
+ * @notice A vault for farming long sided skew against tracer perpetual pools
+ * @dev if skew exists and the vault is active, tradingStats gets updated to reflect wants, enable swaps
+ * @dev if skew ceases to exist, tradingStats gets updated to reflect unwinding and block swaps
+ * @dev Aquiring and disposing must be called mannually for now, and will require role permissions before prod
+ */
 contract LongSkewVault {
     using SafeMath for uint256;
     enum State {

From 1e290bb2505022db809166c21942c9561212d308 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 16:45:29 +1000
Subject: [PATCH 18/45] change name to LongFarmer, make SkewVault

---
 .../{LongSkewVault.sol => LongFarmer.sol}     | 43 +++++++++++++----
 contracts/SkewVault.sol                       | 48 +++++++++++++++++++
 2 files changed, 83 insertions(+), 8 deletions(-)
 rename contracts/{LongSkewVault.sol => LongFarmer.sol} (85%)
 create mode 100644 contracts/SkewVault.sol

diff --git a/contracts/LongSkewVault.sol b/contracts/LongFarmer.sol
similarity index 85%
rename from contracts/LongSkewVault.sol
rename to contracts/LongFarmer.sol
index 6c81835..d64571f 100644
--- a/contracts/LongSkewVault.sol
+++ b/contracts/LongFarmer.sol
@@ -5,14 +5,16 @@ import {L2Encoder} from "./utils/L2Encoder.sol";
 import {IPoolCommitter} from "./interfaces/tracer/IPoolCommitter.sol";
 import {ERC20} from "../lib/solmate/src/tokens/ERC20.sol";
 import {SafeMath} from "../lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol";
+import "./SkewVault.sol";
 
 /**
  * @notice A vault for farming long sided skew against tracer perpetual pools
  * @dev if skew exists and the vault is active, tradingStats gets updated to reflect wants, enable swaps
  * @dev if skew ceases to exist, tradingStats gets updated to reflect unwinding and block swaps
  * @dev Aquiring and disposing must be called mannually for now, and will require role permissions before prod
+ * @dev EC4626 compatible vault must be deployed prior to initialize of this contract
  */
-contract LongSkewVault {
+contract LongFarmer {
     using SafeMath for uint256;
     enum State {
         // The vault is not active
@@ -35,9 +37,9 @@ contract LongSkewVault {
     TradingStats tradingStats; // only used in Active state
     ERC20 USDC;
     ERC20 longToken;
-    ERC20 THREELBTC;
     IPoolCommitter poolCommitter;
     ERC20 vault;
+    SkewVault skewVault;
     address poolAddress;
     bool public tradeLive;
     uint256 public threshold;
@@ -51,7 +53,7 @@ contract LongSkewVault {
     event Log(string _msg);
     event acquired(uint256 _amt);
 
-    constructor(
+    function initialize(
         address _poolAddress,
         uint256 _threshold,
         address _committer,
@@ -65,6 +67,20 @@ contract LongSkewVault {
         encoder = L2Encoder(_encoder);
         tradeLive = false;
         _vault = vault;
+        _vault = skewVault;
+    }
+
+    /**
+     * @notice Returns the value of the vault, in USDC and LongTokens
+     * @dev Utility function for skewVault
+     */
+    function value() public view returns (uint256) {
+        uint256 usdcBal = USDC.balanceOf(address(this));
+        uint256 longBal = longToken.balanceOf(address(this)).add(
+            poolCommitter.getAggregateBalance(address(this)).longTokens
+        );
+        uint256 actualised = longBal.mul(longTokenPrice());
+        return actualised.add(usdcBal);
     }
 
     /**
@@ -78,6 +94,7 @@ contract LongSkewVault {
         uint256 _nextPrice = tradingStats.previousPrice.mul(rate);
         uint256 _previousPrice = tradingStats.previousPrice;
         uint256 _skew = skew();
+        bool _bool = false;
         if (_skew > threshold && state != State.Active) {
             state = State.Active;
             tradingStats.startSkew = _skew;
@@ -85,7 +102,7 @@ contract LongSkewVault {
             uint256 _target = target(rate);
             tradingStats.targetAmt = _target;
             tradingStats.swapping = true;
-            return true;
+            _bool = true;
         }
         if (state == State.Active && _skew > threshold && tradingStats.amtLong > 0) {
             uint256 _amtLong = tradingStats.amtLong;
@@ -93,7 +110,7 @@ contract LongSkewVault {
             uint256 _want = _target.sub(_amtLong);
             tradingStats.want = _want;
             tradingStats.swapping = true;
-            return true;
+            _bool = true;
         }
         if (threshold < _skew) {
             uint256 balance = longToken.balanceOf(address(this)).add(
@@ -104,7 +121,7 @@ contract LongSkewVault {
             emit unwind(balance);
             tradingStats.unWinding = true;
             tradingStats.swapping = false;
-            return false;
+            _bool = false;
         }
         emit Log("pokey pokey");
         window = block.timestamp + 3600;
@@ -112,6 +129,7 @@ contract LongSkewVault {
             poolCommitter.getAggregateBalance(address(this)).longTokens
         );
         tradingStats.previousPrice = longTokenPrice();
+        return _bool;
     }
 
     /**
@@ -144,6 +162,7 @@ contract LongSkewVault {
     function acquire(uint256 _amount) public onlyPlayer {
         require(state == State.Active, "vault must be active to acquire");
         require(tradingStats.unWinding == false, "vault must be aquiring not unwinding");
+        require(skewVault.whiteList[msg.sender], "sender must be whitelisted to aquire");
         tradingStats.swapping = false;
         tradeLive = true;
         bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongMint, agBal(_amount), true);
@@ -153,9 +172,16 @@ contract LongSkewVault {
         tradingStats.want = tradingStats.want.sub(_amount);
     }
 
+    /**
+     * @notice Checks committer aggregate balance, returns bool
+     * @dev if long tokens in aggregate balance are greater than amt, returns true
+     * @param _amt amount of long tokens to be released
+     */
     function agBal(uint256 _amt) public view returns (bool) {
         uint256 lTokens = poolCommitter.getAggregateBalance(address(this)).longTokens;
-        lTokens > _amt ? true : false;
+        bool _bool = false;
+        lTokens > _amt ? _bool = true : _bool = false;
+        return _bool;
     }
 
     /**
@@ -165,7 +191,8 @@ contract LongSkewVault {
      * @dev must be set as role based access when in production
      */
     function dispose(uint256 _amount) public onlyPlayer {
-        require(state == State.Active, "vault must be active to acquire");
+        require(state == State.Active, "vault must be active to dispose");
+        require(skewVault.whiteList[msg.sender], "sender must be whitelisted to dispose");
         bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongBurn, agBal(_amount), true);
         poolCommitter.commit(args);
         tradeLive = false;
diff --git a/contracts/SkewVault.sol b/contracts/SkewVault.sol
new file mode 100644
index 0000000..e00c086
--- /dev/null
+++ b/contracts/SkewVault.sol
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+import {ERC20, ERC4626} from "../lib/solmate/src/mixins/ERC4626.sol";
+import {SafeTransferLib} from "../lib/solmate/src/utils/SafeTransferLib.sol";
+import "@openzeppelin/contracts/access/AccessControl.sol";
+import "./LongFarmer.sol";
+
+/**
+ * @notice An ERC4626 compliant vault for farming long sided skew against tracer perpetual pools
+ * @dev inherets LongFarmer, which contains skew specific logic
+ * @dev vault accepts usdc deposits and withdrawals from whitelisted users
+ */
+contract SkewVault is ERC4626, Ownable, LongFarmer {
+    using SafeTransferLib for ERC20;
+
+    // the underlying token the vault accepts
+    ERC20 public immutable underlying;
+
+    mapping(address => bool) public whiteList;
+
+    constructor(ERC20 _underlying) ERC4626(_underlying, "TracerVault", "TVLT") {
+        underlying = ERC20(_underlying);
+    }
+
+    function totalAssets() public view override returns (uint256) {
+        uint256 bal = value();
+        return underlying.balanceOf(address(this)) + bal;
+    }
+
+    function setWhiteList(address _addr, bool status) external onlyOwner {
+        whiteList[_addr] = status;
+    }
+
+    function afterDeposit(uint256 assets, uint256) internal virtual override onlyWhitelist {
+        require(whiteList[msg.sender] == true);
+    }
+
+    function beforeWithdraw(uint256 assets, uint256) internal virtual override onlyWhitelist {
+        require(whiteList[msg.sender] == true);
+    }
+
+    modifier onlyWhitelist() {
+        require(whiteList[msg.sender], "only whitelisted addresses can use vault");
+        _;
+    }
+}

From a28a48b2b1523642d87e41cd1c9ea482118ad2c8 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 16:58:03 +1000
Subject: [PATCH 19/45] lint

---
 contracts/LongFarmer.sol |  7 +++++--
 contracts/SkewVault.sol  | 14 ++++++++------
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/contracts/LongFarmer.sol b/contracts/LongFarmer.sol
index d64571f..e9f8db0 100644
--- a/contracts/LongFarmer.sol
+++ b/contracts/LongFarmer.sol
@@ -162,7 +162,6 @@ contract LongFarmer {
     function acquire(uint256 _amount) public onlyPlayer {
         require(state == State.Active, "vault must be active to acquire");
         require(tradingStats.unWinding == false, "vault must be aquiring not unwinding");
-        require(skewVault.whiteList[msg.sender], "sender must be whitelisted to aquire");
         tradingStats.swapping = false;
         tradeLive = true;
         bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongMint, agBal(_amount), true);
@@ -192,7 +191,6 @@ contract LongFarmer {
      */
     function dispose(uint256 _amount) public onlyPlayer {
         require(state == State.Active, "vault must be active to dispose");
-        require(skewVault.whiteList[msg.sender], "sender must be whitelisted to dispose");
         bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongBurn, agBal(_amount), true);
         poolCommitter.commit(args);
         tradeLive = false;
@@ -224,6 +222,11 @@ contract LongFarmer {
         return price;
     }
 
+    function returnFunds(uint256 amount) public {
+        require(msg.sender == address(vault), "only vault");
+        USDC.transfer(address(vault), amount);
+    }
+
     modifier onlyPlayer() {
         require(vault.balanceOf(address(msg.sender)) > 1, "Only player can execute");
         _;
diff --git a/contracts/SkewVault.sol b/contracts/SkewVault.sol
index e00c086..c5bf8f2 100644
--- a/contracts/SkewVault.sol
+++ b/contracts/SkewVault.sol
@@ -1,10 +1,9 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 pragma solidity ^0.8.0;
 
-import "@openzeppelin/contracts/access/Ownable.sol";
+import {Ownable} from "../lib/openzeppelin-contracts/contracts/access/Ownable.sol";
 import {ERC20, ERC4626} from "../lib/solmate/src/mixins/ERC4626.sol";
 import {SafeTransferLib} from "../lib/solmate/src/utils/SafeTransferLib.sol";
-import "@openzeppelin/contracts/access/AccessControl.sol";
 import "./LongFarmer.sol";
 
 /**
@@ -12,8 +11,9 @@ import "./LongFarmer.sol";
  * @dev inherets LongFarmer, which contains skew specific logic
  * @dev vault accepts usdc deposits and withdrawals from whitelisted users
  */
-contract SkewVault is ERC4626, Ownable, LongFarmer {
+contract SkewVault is ERC4626, Ownable {
     using SafeTransferLib for ERC20;
+    LongFarmer longFarmer;
 
     // the underlying token the vault accepts
     ERC20 public immutable underlying;
@@ -25,7 +25,7 @@ contract SkewVault is ERC4626, Ownable, LongFarmer {
     }
 
     function totalAssets() public view override returns (uint256) {
-        uint256 bal = value();
+        uint256 bal = longFarmer.value();
         return underlying.balanceOf(address(this)) + bal;
     }
 
@@ -33,12 +33,14 @@ contract SkewVault is ERC4626, Ownable, LongFarmer {
         whiteList[_addr] = status;
     }
 
-    function afterDeposit(uint256 assets, uint256) internal virtual override onlyWhitelist {
+    function afterDeposit(uint256 assets, uint256 shares) internal virtual override {
         require(whiteList[msg.sender] == true);
+        underlying.transfer(address(longFarmer), assets);
     }
 
-    function beforeWithdraw(uint256 assets, uint256) internal virtual override onlyWhitelist {
+    function beforeWithdraw(uint256 assets, uint256 shares) internal virtual override {
         require(whiteList[msg.sender] == true);
+        longFarmer.returnFunds(assets);
     }
 
     modifier onlyWhitelist() {

From c1385b4808a364cfa57418a4d22966001ca8899e Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 17:07:34 +1000
Subject: [PATCH 20/45] dispose and aquire checks

---
 contracts/LongFarmer.sol | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/contracts/LongFarmer.sol b/contracts/LongFarmer.sol
index e9f8db0..6bf797a 100644
--- a/contracts/LongFarmer.sol
+++ b/contracts/LongFarmer.sol
@@ -162,13 +162,14 @@ contract LongFarmer {
     function acquire(uint256 _amount) public onlyPlayer {
         require(state == State.Active, "vault must be active to acquire");
         require(tradingStats.unWinding == false, "vault must be aquiring not unwinding");
+        require(skew() > threshold, "pools must be skewed to acquire");
         tradingStats.swapping = false;
-        tradeLive = true;
         bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongMint, agBal(_amount), true);
         poolCommitter.commit(args);
         emit acquired(_amount);
         tradingStats.amtLong = tradingStats.amtLong.add(_amount);
         tradingStats.want = tradingStats.want.sub(_amount);
+        tradingStats.want > 0 ? tradingStats.swapping = true : tradingStats.swapping = false;
     }
 
     /**
@@ -193,7 +194,9 @@ contract LongFarmer {
         require(state == State.Active, "vault must be active to dispose");
         bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongBurn, agBal(_amount), true);
         poolCommitter.commit(args);
-        tradeLive = false;
+        tradingStats.want = tradingStats.want.sub(_amount);
+        tradingStats.amtLong = tradingStats.amtLong.sub(_amount);
+        tradingStats.want > 1000 ? tradingStats.swapping = true : tradingStats.swapping = false;
     }
 
     /**

From d2d09a95ab21266233e5c76d89b59829aa7f784a Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 17:58:36 +1000
Subject: [PATCH 21/45] add nextSkew calculaton and check in poke function

---
 contracts/LongFarmer.sol | 35 +++++++++++++++++++++++++++--------
 1 file changed, 27 insertions(+), 8 deletions(-)

diff --git a/contracts/LongFarmer.sol b/contracts/LongFarmer.sol
index 6bf797a..75c906a 100644
--- a/contracts/LongFarmer.sol
+++ b/contracts/LongFarmer.sol
@@ -30,6 +30,7 @@ contract LongFarmer {
         uint256 targetAmt;
         bool swapping;
         bool unWinding;
+        bool stopping;
         uint256 amtLong;
         uint256 want;
     }
@@ -46,10 +47,7 @@ contract LongFarmer {
     uint256 window;
     ILeveragedPool public pool;
     L2Encoder encoder;
-    event holding(uint256 _amt);
     event unwind(uint256 _amt);
-    event releasing(uint256 _amt);
-    event noAction(uint256 _skew);
     event Log(string _msg);
     event acquired(uint256 _amt);
 
@@ -91,8 +89,6 @@ contract LongFarmer {
     function poke() public returns (bool) {
         require(window < block.timestamp, "poke can only be called hourly");
         uint256 rate = tradingStats.previousPrice.div(longTokenPrice());
-        uint256 _nextPrice = tradingStats.previousPrice.mul(rate);
-        uint256 _previousPrice = tradingStats.previousPrice;
         uint256 _skew = skew();
         bool _bool = false;
         if (_skew > threshold && state != State.Active) {
@@ -102,6 +98,8 @@ contract LongFarmer {
             uint256 _target = target(rate);
             tradingStats.targetAmt = _target;
             tradingStats.swapping = true;
+            tradingStats.unWinding = false;
+            tradingStats.stopping = false;
             _bool = true;
         }
         if (state == State.Active && _skew > threshold && tradingStats.amtLong > 0) {
@@ -110,9 +108,11 @@ contract LongFarmer {
             uint256 _want = _target.sub(_amtLong);
             tradingStats.want = _want;
             tradingStats.swapping = true;
+            tradingStats.unWinding = false;
+            tradingStats.stopping = false;
             _bool = true;
         }
-        if (threshold < _skew) {
+        if (threshold > _skew) {
             uint256 balance = longToken.balanceOf(address(this)).add(
                 poolCommitter.getAggregateBalance(address(this)).longTokens
             );
@@ -123,6 +123,12 @@ contract LongFarmer {
             tradingStats.swapping = false;
             _bool = false;
         }
+        if (nextSkew(rate) < threshold) {
+            tradingStats.swapping = false;
+            tradingStats.stopping = true;
+            emit Log("no more skew");
+            _bool = false;
+        }
         emit Log("pokey pokey");
         window = block.timestamp + 3600;
         tradingStats.amtLong = longToken.balanceOf(address(this)).add(
@@ -141,6 +147,18 @@ contract LongFarmer {
         return _skew;
     }
 
+    /**
+     * @notice Returns the predicted next skew
+     * @param _rate the current rate of change
+     */
+    function nextSkew(uint256 _rate) public view returns (uint256) {
+        uint256 sBal = pool.shortBalance().mul(1 - _rate);
+        uint256 lBal = pool.longBalance().mul(_rate);
+        uint256 _s = sBal / lBal;
+        uint256 _nS = _s.mul(_rate);
+        return _nS;
+    }
+
     /**
      * @notice Gets the target value of wants for the vault to bring skew back to 1
      * @param _rate rate of change of long token from previous price
@@ -148,8 +166,8 @@ contract LongFarmer {
     function target(uint256 _rate) public view returns (uint256) {
         uint256 _shortBal = pool.shortBalance().mul(1 - _rate);
         uint256 _LongBal = pool.longBalance().mul(_rate);
-        uint256 _skew = _shortBal / _LongBal;
-        uint256 _t = _shortBal / _skew;
+        uint256 _s = _shortBal / _LongBal;
+        uint256 _t = _shortBal / _s;
         uint256 _target = _t - _LongBal;
         return _target;
     }
@@ -163,6 +181,7 @@ contract LongFarmer {
         require(state == State.Active, "vault must be active to acquire");
         require(tradingStats.unWinding == false, "vault must be aquiring not unwinding");
         require(skew() > threshold, "pools must be skewed to acquire");
+        require(tradingStats.stopping == false, "next skew under threshold");
         tradingStats.swapping = false;
         bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongMint, agBal(_amount), true);
         poolCommitter.commit(args);

From 43303739fec01ef06c4ad04a6d8915e73da261bf Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 18:27:51 +1000
Subject: [PATCH 22/45] add LongFarmer to constructor

---
 contracts/SkewVault.sol | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/contracts/SkewVault.sol b/contracts/SkewVault.sol
index c5bf8f2..df5347e 100644
--- a/contracts/SkewVault.sol
+++ b/contracts/SkewVault.sol
@@ -22,6 +22,7 @@ contract SkewVault is ERC4626, Ownable {
 
     constructor(ERC20 _underlying) ERC4626(_underlying, "TracerVault", "TVLT") {
         underlying = ERC20(_underlying);
+        longFarmer = new LongFarmer();
     }
 
     function totalAssets() public view override returns (uint256) {
@@ -33,6 +34,10 @@ contract SkewVault is ERC4626, Ownable {
         whiteList[_addr] = status;
     }
 
+    function setLongFarmer(address _longFarmer) public onlyOwner {
+        longFarmer = LongFarmer(_longFarmer);
+    }
+
     function afterDeposit(uint256 assets, uint256 shares) internal virtual override {
         require(whiteList[msg.sender] == true);
         underlying.transfer(address(longFarmer), assets);

From b0b7e26f6516d6f555acfa9fbdd27cb7d6144654 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 18:30:41 +1000
Subject: [PATCH 23/45] constructor: approve underlying for spend in longFarmer

---
 contracts/SkewVault.sol | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contracts/SkewVault.sol b/contracts/SkewVault.sol
index df5347e..2645a87 100644
--- a/contracts/SkewVault.sol
+++ b/contracts/SkewVault.sol
@@ -23,6 +23,7 @@ contract SkewVault is ERC4626, Ownable {
     constructor(ERC20 _underlying) ERC4626(_underlying, "TracerVault", "TVLT") {
         underlying = ERC20(_underlying);
         longFarmer = new LongFarmer();
+        underlying.approve(address(longFarmer), 1e18);
     }
 
     function totalAssets() public view override returns (uint256) {

From 502c40baaf4fbe82b958eb01a181c9642bd3cd0d Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 18:41:28 +1000
Subject: [PATCH 24/45] change to using setLongFarm

---
 contracts/SkewVault.sol | 1 -
 1 file changed, 1 deletion(-)

diff --git a/contracts/SkewVault.sol b/contracts/SkewVault.sol
index 2645a87..df5347e 100644
--- a/contracts/SkewVault.sol
+++ b/contracts/SkewVault.sol
@@ -23,7 +23,6 @@ contract SkewVault is ERC4626, Ownable {
     constructor(ERC20 _underlying) ERC4626(_underlying, "TracerVault", "TVLT") {
         underlying = ERC20(_underlying);
         longFarmer = new LongFarmer();
-        underlying.approve(address(longFarmer), 1e18);
     }
 
     function totalAssets() public view override returns (uint256) {

From aa97bac200f2e099b38ffe8d275308beebe417f9 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 19:12:42 +1000
Subject: [PATCH 25/45] forge install: ds-test

---
 .gitmodules | 3 +++
 lib/ds-test | 1 +
 2 files changed, 4 insertions(+)
 create mode 160000 lib/ds-test

diff --git a/.gitmodules b/.gitmodules
index e985ad5..eff2e43 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -25,3 +25,6 @@
 [submodule "lib/perpetual-pools-contracts"]
 	path = lib/perpetual-pools-contracts
 	url = https://github.com/tracer-protocol/perpetual-pools-contracts
+[submodule "lib/ds-test"]
+	path = lib/ds-test
+	url = https://github.com/dapphub/ds-test
diff --git a/lib/ds-test b/lib/ds-test
new file mode 160000
index 0000000..2c7dbcc
--- /dev/null
+++ b/lib/ds-test
@@ -0,0 +1 @@
+Subproject commit 2c7dbcc8586b33f358e3307a443e524490c17666

From 507f5a4d3181a92760d8ccd729466c1161634b8b Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 19:16:04 +1000
Subject: [PATCH 26/45] forge install: foundry-playground

---
 .gitmodules            | 3 +++
 lib/foundry-playground | 1 +
 2 files changed, 4 insertions(+)
 create mode 160000 lib/foundry-playground

diff --git a/.gitmodules b/.gitmodules
index eff2e43..613161c 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -28,3 +28,6 @@
 [submodule "lib/ds-test"]
 	path = lib/ds-test
 	url = https://github.com/dapphub/ds-test
+[submodule "lib/foundry-playground"]
+	path = lib/foundry-playground
+	url = https://github.com/dekz/foundry-playground
diff --git a/lib/foundry-playground b/lib/foundry-playground
new file mode 160000
index 0000000..ae18323
--- /dev/null
+++ b/lib/foundry-playground
@@ -0,0 +1 @@
+Subproject commit ae18323cbf6696e000e0770b6137f60842232411

From 1c188231b42bc0f7ca0a535e21d2f53d915b5f6d Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 19:47:18 +1000
Subject: [PATCH 27/45] deposit test

---
 foundry.toml         |  6 +++++-
 test/SkewVault.t.sol | 38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+), 1 deletion(-)
 create mode 100644 test/SkewVault.t.sol

diff --git a/foundry.toml b/foundry.toml
index 2ba59a0..6cb421f 100644
--- a/foundry.toml
+++ b/foundry.toml
@@ -2,6 +2,10 @@
 src = 'contracts'
 out = 'out'
 libs = ['lib']
-remappings = ['@openzeppelin/=node_modules/@openzeppelin/contracts/']
+
+remappings =  [
+    '@openzeppelin/=lib/openzeppelin-contracts/'
+]
+
 
 # See more config options https://github.com/gakonst/foundry/tree/master/config
\ No newline at end of file
diff --git a/test/SkewVault.t.sol b/test/SkewVault.t.sol
new file mode 100644
index 0000000..4ef7ede
--- /dev/null
+++ b/test/SkewVault.t.sol
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+import "../lib/ds-test/src/test.sol";
+import "../lib/foundry-playground/src/ERC20TokenFaker.sol";
+import "../lib/foundry-playground/src/FakeERC20.sol";
+import "../contracts/LongFarmer.sol";
+import "../contracts/SkewVault.sol";
+
+interface Vm {
+    function warp(uint256 x) external;
+    function expectRevert(bytes calldata) external;
+    function roll(uint256) external;
+    function prank(address) external;
+}
+
+contract SkewVaulttest is DSTest, ERC20TokenFaker {
+    FakeERC20 FAKE;
+    LongFarmer longFarmer;
+    SkewVault skewVault;
+    Vm VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
+
+    function setUp(){
+        fUSD = new FakeERC20(0xd1f6A92a9a4FA84e7D4d2E1Ab010B4032B678EdE);
+        longFarmer = new LongFarmer();
+        skewVaults = new SkewVault(fUSD);
+        longFarmer.setSkewVault(skewVault);
+        fUSD._setBalance(address(this), 1e18);
+        fUSD.approve(address(skewVault), 1e18);
+    }
+
+    //test deposit
+    function deposit(uint256 assets) public {
+        skewVault.deposit(assets);
+        assert(fUSD.balanceOf(address(skewVault)) == assets);
+    }
+
+}
\ No newline at end of file

From da4b3ba1eafb0dfa9f35edcba0f0ff9380bcdf0b Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Thu, 21 Apr 2022 19:47:54 +1000
Subject: [PATCH 28/45] lint

---
 test/SkewVault.t.sol | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/test/SkewVault.t.sol b/test/SkewVault.t.sol
index 4ef7ede..fc7a33b 100644
--- a/test/SkewVault.t.sol
+++ b/test/SkewVault.t.sol
@@ -9,8 +9,11 @@ import "../contracts/SkewVault.sol";
 
 interface Vm {
     function warp(uint256 x) external;
+
     function expectRevert(bytes calldata) external;
+
     function roll(uint256) external;
+
     function prank(address) external;
 }
 
@@ -20,7 +23,7 @@ contract SkewVaulttest is DSTest, ERC20TokenFaker {
     SkewVault skewVault;
     Vm VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
 
-    function setUp(){
+    function setUp() {
         fUSD = new FakeERC20(0xd1f6A92a9a4FA84e7D4d2E1Ab010B4032B678EdE);
         longFarmer = new LongFarmer();
         skewVaults = new SkewVault(fUSD);
@@ -34,5 +37,4 @@ contract SkewVaulttest is DSTest, ERC20TokenFaker {
         skewVault.deposit(assets);
         assert(fUSD.balanceOf(address(skewVault)) == assets);
     }
-
-}
\ No newline at end of file
+}

From 5c26fa5e114a0e97236b9bb9f53cdfe8ef22fe86 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 22 Apr 2022 11:42:27 +1000
Subject: [PATCH 29/45] test withdraw and deposit, change value() function
 logic

---
 contracts/LongFarmer.sol | 26 ++++++++++++++++-------
 contracts/SkewVault.sol  | 13 ++++++++----
 foundry.toml             |  4 +++-
 test/SkewVault.t.sol     | 46 ++++++++++++++++++++++++++++------------
 4 files changed, 63 insertions(+), 26 deletions(-)

diff --git a/contracts/LongFarmer.sol b/contracts/LongFarmer.sol
index 75c906a..05abbaf 100644
--- a/contracts/LongFarmer.sol
+++ b/contracts/LongFarmer.sol
@@ -66,6 +66,7 @@ contract LongFarmer {
         tradeLive = false;
         _vault = vault;
         _vault = skewVault;
+        USDC = ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6);
     }
 
     /**
@@ -73,12 +74,12 @@ contract LongFarmer {
      * @dev Utility function for skewVault
      */
     function value() public view returns (uint256) {
-        uint256 usdcBal = USDC.balanceOf(address(this));
-        uint256 longBal = longToken.balanceOf(address(this)).add(
-            poolCommitter.getAggregateBalance(address(this)).longTokens
-        );
-        uint256 actualised = longBal.mul(longTokenPrice());
-        return actualised.add(usdcBal);
+        uint256 usdcBal = ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).balanceOf(address(this));
+        if (state == State.Active) {
+            uint256 _adj = tradingStats.amtLong.mul(longTokenPrice());
+            usdcBal += _adj;
+        }
+        return usdcBal;
     }
 
     /**
@@ -244,9 +245,18 @@ contract LongFarmer {
         return price;
     }
 
+    function setSkewVault(address _vault) public {
+        skewVault = SkewVault(_vault);
+        vault = ERC20(_vault);
+        USDC.approve(address(skewVault), 1e18);
+    }
+
+    function rxFunds(uint256 _amt) public {
+        USDC.transferFrom(address(vault), address(this), _amt);
+    }
+
     function returnFunds(uint256 amount) public {
-        require(msg.sender == address(vault), "only vault");
-        USDC.transfer(address(vault), amount);
+        USDC.transfer(address(skewVault), amount);
     }
 
     modifier onlyPlayer() {
diff --git a/contracts/SkewVault.sol b/contracts/SkewVault.sol
index df5347e..920b9d8 100644
--- a/contracts/SkewVault.sol
+++ b/contracts/SkewVault.sol
@@ -20,14 +20,15 @@ contract SkewVault is ERC4626, Ownable {
 
     mapping(address => bool) public whiteList;
 
-    constructor(ERC20 _underlying) ERC4626(_underlying, "TracerVault", "TVLT") {
+    constructor(address _underlying) ERC4626(ERC20(_underlying), "TracerVault", "TVLT") {
         underlying = ERC20(_underlying);
-        longFarmer = new LongFarmer();
     }
 
     function totalAssets() public view override returns (uint256) {
         uint256 bal = longFarmer.value();
-        return underlying.balanceOf(address(this)) + bal;
+        uint256 _t = underlying.balanceOf(address(this));
+        bal += _t;
+        return bal;
     }
 
     function setWhiteList(address _addr, bool status) external onlyOwner {
@@ -36,11 +37,15 @@ contract SkewVault is ERC4626, Ownable {
 
     function setLongFarmer(address _longFarmer) public onlyOwner {
         longFarmer = LongFarmer(_longFarmer);
+        underlying.approve(address(longFarmer), 1e18);
     }
 
     function afterDeposit(uint256 assets, uint256 shares) internal virtual override {
         require(whiteList[msg.sender] == true);
-        underlying.transfer(address(longFarmer), assets);
+
+        // longFarmer.rxFunds(assets);
+        // // underlying.safeTransferFrom(address(this), address(longFarmer), assets);
+        underlying.safeTransfer(address(longFarmer), assets);
     }
 
     function beforeWithdraw(uint256 assets, uint256 shares) internal virtual override {
diff --git a/foundry.toml b/foundry.toml
index 6cb421f..ed54267 100644
--- a/foundry.toml
+++ b/foundry.toml
@@ -6,6 +6,8 @@ libs = ['lib']
 remappings =  [
     '@openzeppelin/=lib/openzeppelin-contracts/'
 ]
-
+[hardhat]
+src = "contracts"
+test = "test"
 
 # See more config options https://github.com/gakonst/foundry/tree/master/config
\ No newline at end of file
diff --git a/test/SkewVault.t.sol b/test/SkewVault.t.sol
index fc7a33b..fddb476 100644
--- a/test/SkewVault.t.sol
+++ b/test/SkewVault.t.sol
@@ -4,8 +4,9 @@ pragma solidity ^0.8.10;
 import "../lib/ds-test/src/test.sol";
 import "../lib/foundry-playground/src/ERC20TokenFaker.sol";
 import "../lib/foundry-playground/src/FakeERC20.sol";
-import "../contracts/LongFarmer.sol";
-import "../contracts/SkewVault.sol";
+import {LongFarmer} from "../contracts/LongFarmer.sol";
+import {SkewVault} from "../contracts/SkewVault.sol";
+import {ERC20} from "../lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
 
 interface Vm {
     function warp(uint256 x) external;
@@ -18,23 +19,42 @@ interface Vm {
 }
 
 contract SkewVaulttest is DSTest, ERC20TokenFaker {
-    FakeERC20 FAKE;
     LongFarmer longFarmer;
     SkewVault skewVault;
-    Vm VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
+    FakeERC20 fUSD;
+    ERC20 tUSD;
 
-    function setUp() {
-        fUSD = new FakeERC20(0xd1f6A92a9a4FA84e7D4d2E1Ab010B4032B678EdE);
+    // Vm VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
+    // Use below for forked network testing
+    // forge test -vvv --fork-url https://arb-rinkeby.g.alchemy.com/v2/2LMiiNiXkk1CYIlXLjVFottvrUUnz4ps
+
+    function setUp() public {
+        fUSD = fakeOutERC20(address(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6));
+        skewVault = new SkewVault(address(fUSD));
         longFarmer = new LongFarmer();
-        skewVaults = new SkewVault(fUSD);
-        longFarmer.setSkewVault(skewVault);
-        fUSD._setBalance(address(this), 1e18);
         fUSD.approve(address(skewVault), 1e18);
+        fUSD._setBalance(address(this), 1e18);
+        skewVault.setWhiteList(address(this), true);
+        longFarmer.initialize(
+            0x5dC60E2AB4bE89691264445401d427A15Bb897C6,
+            1000,
+            0xa5C800867C42fa506E2384f3Da18F400E8E208FB,
+            0xCB4fc400Cf54fC62db179F7e0C9867B6f52cd58d,
+            skewVault
+        );
+        longFarmer.setSkewVault(address(skewVault));
+        skewVault.setLongFarmer(address(longFarmer));
+        fUSD.approve(address(longFarmer), 1e18);
+    }
+
+    function testDeposit() public {
+        skewVault.deposit(1000000, address(this));
+        assert(ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).balanceOf(address(longFarmer)) == 1000000);
     }
 
-    //test deposit
-    function deposit(uint256 assets) public {
-        skewVault.deposit(assets);
-        assert(fUSD.balanceOf(address(skewVault)) == assets);
+    function testWithdraw() public {
+        skewVault.deposit(1000000, address(this));
+        skewVault.withdraw(1000000, address(this), address(this));
+        assert(ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).balanceOf(address(longFarmer)) == 0);
     }
 }

From d161617bdf87322dd0206caa9a4e5bcb1b8d1e30 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Fri, 22 Apr 2022 15:47:11 +1000
Subject: [PATCH 30/45] deposit + withdraw passing, testCommit Fails

---
 contracts/LongFarmer.sol | 61 +++++++++++++++++++++++++++++++++-------
 contracts/SkewVault.sol  |  4 +++
 test/SkewVault.t.sol     | 46 +++++++++++++++++++++++++++---
 3 files changed, 97 insertions(+), 14 deletions(-)

diff --git a/contracts/LongFarmer.sol b/contracts/LongFarmer.sol
index 05abbaf..f8cf706 100644
--- a/contracts/LongFarmer.sol
+++ b/contracts/LongFarmer.sol
@@ -6,6 +6,7 @@ import {IPoolCommitter} from "./interfaces/tracer/IPoolCommitter.sol";
 import {ERC20} from "../lib/solmate/src/tokens/ERC20.sol";
 import {SafeMath} from "../lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol";
 import "./SkewVault.sol";
+import {Ownable} from "../lib/openzeppelin-contracts/contracts/access/Ownable.sol";
 
 /**
  * @notice A vault for farming long sided skew against tracer perpetual pools
@@ -14,7 +15,7 @@ import "./SkewVault.sol";
  * @dev Aquiring and disposing must be called mannually for now, and will require role permissions before prod
  * @dev EC4626 compatible vault must be deployed prior to initialize of this contract
  */
-contract LongFarmer {
+contract LongFarmer is Ownable {
     using SafeMath for uint256;
     enum State {
         // The vault is not active
@@ -33,6 +34,7 @@ contract LongFarmer {
         bool stopping;
         uint256 amtLong;
         uint256 want;
+        bool testing;
     }
     State state;
     TradingStats tradingStats; // only used in Active state
@@ -67,6 +69,20 @@ contract LongFarmer {
         _vault = vault;
         _vault = skewVault;
         USDC = ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6);
+        longToken = ERC20(0x4AaDc48087b569dD3E65dBe65B0dD036891767e3);
+        longToken.approve(address(poolCommitter), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+        ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).approve(
+            address(poolCommitter),
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
+        ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).allowance(
+            address(0xC3d2052479dBC010480Ae16204777C1469CEffC9),
+            address(this)
+        );
+        ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).approve(
+            address(0xC3d2052479dBC010480Ae16204777C1469CEffC9),
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
     }
 
     /**
@@ -144,8 +160,12 @@ contract LongFarmer {
      * @dev returns skew
      */
     function skew() public view returns (uint256) {
-        uint256 _skew = pool.shortBalance() / pool.longBalance();
-        return _skew;
+        if (tradingStats.testing == true) {
+            return 10000;
+        } else {
+            uint256 _s = pool.shortBalance() / pool.longBalance();
+            return _s;
+        }
     }
 
     /**
@@ -178,13 +198,17 @@ contract LongFarmer {
      * @dev only call when swaps cant fulfil wants
      * @param _amount amount of long tokens to be aquired
      */
-    function acquire(uint256 _amount) public onlyPlayer {
+    function acquire(uint256 _amount) public {
         require(state == State.Active, "vault must be active to acquire");
         require(tradingStats.unWinding == false, "vault must be aquiring not unwinding");
         require(skew() > threshold, "pools must be skewed to acquire");
-        require(tradingStats.stopping == false, "next skew under threshold");
+        require(tradingStats.stopping != true, "next skew under threshold");
+        USDC.approve(
+            address(0xC3d2052479dBC010480Ae16204777C1469CEffC9),
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
         tradingStats.swapping = false;
-        bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongMint, agBal(_amount), true);
+        bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongMint, false, true);
         poolCommitter.commit(args);
         emit acquired(_amount);
         tradingStats.amtLong = tradingStats.amtLong.add(_amount);
@@ -212,7 +236,7 @@ contract LongFarmer {
      */
     function dispose(uint256 _amount) public onlyPlayer {
         require(state == State.Active, "vault must be active to dispose");
-        bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongBurn, agBal(_amount), true);
+        bytes32 args = encoder.encodeCommitParams(_amount, IPoolCommitter.CommitType.LongBurn, false, false);
         poolCommitter.commit(args);
         tradingStats.want = tradingStats.want.sub(_amount);
         tradingStats.amtLong = tradingStats.amtLong.sub(_amount);
@@ -229,20 +253,37 @@ contract LongFarmer {
         require(state == State.Active, "Vault is not active");
         require(tradingStats.unWinding == false, "Vault is unwinding");
         require(tradingStats.swapping == true, "Vault is not swapping");
-        longToken.transfer(address(this), _amtLong);
+        longToken.approve(address(this), 1e18);
+        longToken.transferFrom(address(msg.sender), address(this), _amtLong);
         uint256 _out = longTokenPrice().mul(_amtLong);
-        USDC.transfer(msg.sender, _out);
+        ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).transfer(address(msg.sender), _out);
         require(_out > _minAmtUSDC, "Not enough USDC");
         return _out;
     }
 
     /**
      * @notice getter for long token price
+     * @notice remove when not testing
+     *
      */
     function longTokenPrice() public view returns (uint256) {
         uint256 bal = pool.longBalance();
         uint256 price = bal.div(longToken.totalSupply());
-        return price;
+        if (price == 0) {
+            return 10000;
+        } else {
+            return price;
+        }
+    }
+
+    /**
+     * @notice Setter for Testing purposes only
+     *
+     */
+    function setActive() public onlyOwner {
+        state = State.Active;
+        tradingStats.swapping = true;
+        tradingStats.testing = true;
     }
 
     function setSkewVault(address _vault) public {
diff --git a/contracts/SkewVault.sol b/contracts/SkewVault.sol
index 920b9d8..3629051 100644
--- a/contracts/SkewVault.sol
+++ b/contracts/SkewVault.sol
@@ -38,6 +38,10 @@ contract SkewVault is ERC4626, Ownable {
     function setLongFarmer(address _longFarmer) public onlyOwner {
         longFarmer = LongFarmer(_longFarmer);
         underlying.approve(address(longFarmer), 1e18);
+        ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).allowance(
+            address(0xC3d2052479dBC010480Ae16204777C1469CEffC9),
+            address(longFarmer)
+        );
     }
 
     function afterDeposit(uint256 assets, uint256 shares) internal virtual override {
diff --git a/test/SkewVault.t.sol b/test/SkewVault.t.sol
index fddb476..0d083f0 100644
--- a/test/SkewVault.t.sol
+++ b/test/SkewVault.t.sol
@@ -7,8 +7,9 @@ import "../lib/foundry-playground/src/FakeERC20.sol";
 import {LongFarmer} from "../contracts/LongFarmer.sol";
 import {SkewVault} from "../contracts/SkewVault.sol";
 import {ERC20} from "../lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
+import {SafeMath} from "../lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol";
 
-interface Vm {
+interface Cheats {
     function warp(uint256 x) external;
 
     function expectRevert(bytes calldata) external;
@@ -19,12 +20,16 @@ interface Vm {
 }
 
 contract SkewVaulttest is DSTest, ERC20TokenFaker {
+    using SafeMath for uint256;
     LongFarmer longFarmer;
     SkewVault skewVault;
     FakeERC20 fUSD;
+    FakeERC20 longT;
     ERC20 tUSD;
+    event Log(string);
+
+    Cheats cheats = Cheats(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
 
-    // Vm VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
     // Use below for forked network testing
     // forge test -vvv --fork-url https://arb-rinkeby.g.alchemy.com/v2/2LMiiNiXkk1CYIlXLjVFottvrUUnz4ps
 
@@ -36,15 +41,16 @@ contract SkewVaulttest is DSTest, ERC20TokenFaker {
         fUSD._setBalance(address(this), 1e18);
         skewVault.setWhiteList(address(this), true);
         longFarmer.initialize(
-            0x5dC60E2AB4bE89691264445401d427A15Bb897C6,
+            0x8155a758a06E7e385191C119D35195Aa743cBe9f,
             1000,
-            0xa5C800867C42fa506E2384f3Da18F400E8E208FB,
+            0xC3d2052479dBC010480Ae16204777C1469CEffC9,
             0xCB4fc400Cf54fC62db179F7e0C9867B6f52cd58d,
             skewVault
         );
         longFarmer.setSkewVault(address(skewVault));
         skewVault.setLongFarmer(address(longFarmer));
         fUSD.approve(address(longFarmer), 1e18);
+        fUSD.allowance(address(0xC3d2052479dBC010480Ae16204777C1469CEffC9), address(longFarmer));
     }
 
     function testDeposit() public {
@@ -57,4 +63,36 @@ contract SkewVaulttest is DSTest, ERC20TokenFaker {
         skewVault.withdraw(1000000, address(this), address(this));
         assert(ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).balanceOf(address(longFarmer)) == 0);
     }
+
+    function testLongSwap() public {
+        longT = fakeOutERC20(address(0x4AaDc48087b569dD3E65dBe65B0dD036891767e3));
+        longT._setBalance(address(this), 1e18);
+        fUSD._setBalance(address(longFarmer), 1e18);
+        longFarmer.setActive();
+        longT.approve(address(longFarmer), 1e18);
+        uint256 want = 10000000;
+        uint256 _lP = 1;
+        longFarmer._swap(10000000, _lP);
+    }
+
+    function testCommit() public {
+        fUSD._setBalance(address(longFarmer), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); // onlyPlayer
+        longFarmer.setActive();
+        longFarmer.acquire(100000);
+        emit Log("commit");
+        // VM.roll(1 days);
+        // ERC20(0x4AaDc48087b569dD3E65dBe65B0dD036891767e3).approve(0xC3d2052479dBC010480Ae16204777C1469CEffC9, 1e18);
+        // longFarmer.dispose(1000);
+        // emit Log("commit burn");
+        // VM.roll(1 days);
+        // assert(ERC20(0x4AaDc48087b569dD3E65dBe65B0dD036891767e3).balanceOf(address(longFarmer)) < 10000000);
+        // longT = fakeOutERC20(address(0x4AaDc48087b569dD3E65dBe65B0dD036891767e3)); // 7x Long ETH
+        // longT._setBalance(address(longFarmer), 10000000000000000000000000);
+        // longT._setBalance(address(this), 10000000000000000000000000);
+        // longT.approve(0xC3d2052479dBC010480Ae16204777C1469CEffC9, 1e18);
+        // longT.approve(address(longFarmer), 1e18);
+        // uint256 want = 100;
+
+        // longFarmer.dispose(want);
+    }
 }

From 5cd22330e24d7c9eec11488236908f2bf4af1885 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 11:07:38 +1000
Subject: [PATCH 31/45] docs update

---
 contracts/LongFarmer.sol   |  7 ++++++-
 contracts/SkewVault.sol    | 10 +++++++++-
 docs/LongFarmer.md         | 28 ++++++++++++++++++++++++++++
 docs/Permissions.md        | 13 +++++++++++++
 docs/Skew.md               | 10 ++++++++++
 docs/Vault.md              | 20 ++++++++++++++++++++
 lib/openzeppelin-contracts |  2 +-
 lib/solmate                |  2 +-
 8 files changed, 88 insertions(+), 4 deletions(-)
 create mode 100644 docs/LongFarmer.md
 create mode 100644 docs/Permissions.md
 create mode 100644 docs/Skew.md
 create mode 100644 docs/Vault.md

diff --git a/contracts/LongFarmer.sol b/contracts/LongFarmer.sol
index f8cf706..edaf725 100644
--- a/contracts/LongFarmer.sol
+++ b/contracts/LongFarmer.sol
@@ -7,6 +7,7 @@ import {ERC20} from "../lib/solmate/src/tokens/ERC20.sol";
 import {SafeMath} from "../lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol";
 import "./SkewVault.sol";
 import {Ownable} from "../lib/openzeppelin-contracts/contracts/access/Ownable.sol";
+import "../lib/openzeppelin-contracts/contracts/proxy/utils/Initializable.sol";
 
 /**
  * @notice A vault for farming long sided skew against tracer perpetual pools
@@ -198,7 +199,7 @@ contract LongFarmer is Ownable {
      * @dev only call when swaps cant fulfil wants
      * @param _amount amount of long tokens to be aquired
      */
-    function acquire(uint256 _amount) public {
+    function acquire(uint256 _amount) public onlyWhitelist{
         require(state == State.Active, "vault must be active to acquire");
         require(tradingStats.unWinding == false, "vault must be aquiring not unwinding");
         require(skew() > threshold, "pools must be skewed to acquire");
@@ -309,4 +310,8 @@ contract LongFarmer is Ownable {
         require(skew() > threshold, "only swap when skewed");
         _;
     }
+    modifier onlyWhitelist() {
+        require(skewVault.whiteList(msg.sender)  == true, "Only whitelisted accounts can execute");
+        _;
+    }
 }
diff --git a/contracts/SkewVault.sol b/contracts/SkewVault.sol
index 3629051..2919d33 100644
--- a/contracts/SkewVault.sol
+++ b/contracts/SkewVault.sol
@@ -20,8 +20,16 @@ contract SkewVault is ERC4626, Ownable {
 
     mapping(address => bool) public whiteList;
 
-    constructor(address _underlying) ERC4626(ERC20(_underlying), "TracerVault", "TVLT") {
+    constructor(
+        address _underlying,
+        address pooladdr,
+        uint256 _threshold,
+        address _committer,
+        address _encoder
+    ) ERC4626(ERC20(_underlying), "TracerVault", "TVLT") {
         underlying = ERC20(_underlying);
+        longFarmer = new LongFarmer();
+        longFarmer.initialize(pooladdr, _threshold, _committer, _encoder, ERC20(this));
     }
 
     function totalAssets() public view override returns (uint256) {
diff --git a/docs/LongFarmer.md b/docs/LongFarmer.md
new file mode 100644
index 0000000..c1f2bf1
--- /dev/null
+++ b/docs/LongFarmer.md
@@ -0,0 +1,28 @@
+### LongFarmer Docs
+The longFarmer contract contains all logic relevant to tracking skew, adjusting skew defined positions, enabling skew defined swaps, and offloading assets when not skewed. 
+
+## Spec
+`initialize`: Params passed to initialize set the state variables for the contract, including the vault address. This function should be called from within the Vault.sol Constructor.
+
+`value`: Returns the current value of the LongFarmer, in usdc. Accounts for aggregate balance in `poolCommitter`. 
+
+`poke`: This function is called at regular intervals (predefined by `window`) to check for a skew, and act accordingly. Currently, the logic simply sets the vault state, `Active` if a skew exists, which turns on the contingent parameters that facilitate long skew farming.
+
+`window`: Public variable which sets the next poke period. 
+
+`nextSkew`: Calculates the anticipated next skew, based on rate of change. 
+
+`target`: Calculates the target amount of longtTokens to acquire, to bring skew back to 1. 
+
+`acquire`: Acquires longPool Tokens. Vault must be active, not unwinding, not stopping and have a valid skew > threshold at next skew. Currently, this function relies on end users forecasting the skew at next commit, based off SMA of previous ~8 samples of price. This function may only be called by whitelisted EOA's. 
+
+`dispose`: Much like Acquire, dispose handles the logic for offloading long tokens in the abscence of a skew. This function also relies on EOA's performing the predicted upcoming forecasted state, prior to acting on this function. Again, only whitelisted EOA's may call this function. 
+
+`agBal`: A helper function to discern wether funds come from poolCommitter aggregate balance, or from the longFarmer internal balance. 
+
+`_swap`: A swap function allowing EOA's to swap `longTokens` for `USDC` at the current price. Can only be called when a skew exists, and the vault is set to active. 
+
+`longTokenPrice`: Returns the current price of long tokens, in USDC. 
+
+`setActive`: **important** setActive is a helper function for testing purposes, and should not be pushed to prod. 
+
diff --git a/docs/Permissions.md b/docs/Permissions.md
new file mode 100644
index 0000000..4fca4f8
--- /dev/null
+++ b/docs/Permissions.md
@@ -0,0 +1,13 @@
+### Permissions
+This document outlines permissioning for the Vault and LongFarmer contracts. 
+
+## Modifiers
+`onlyPlayer`: Only vault token holders can interact with functions marked `onlyPlayer`.
+
+`onlyWhenSkewed()`: Only perform the relevant function when a skew exists.
+
+`onlyWhitelist`: only whitelisted addresses may interact with functions attracting this modifier. 
+
+`mapping(address => bool) public whiteList`: Mapping containing whitelisted addresses for the above.
+
+`onlyOwner`: Only the contract owner may perform this function. 
\ No newline at end of file
diff --git a/docs/Skew.md b/docs/Skew.md
new file mode 100644
index 0000000..93d2b76
--- /dev/null
+++ b/docs/Skew.md
@@ -0,0 +1,10 @@
+### Skew: Explained
+Perpetual Pools is a derivative contract that swaps collateral between the long and short sides of one pool – when the collateral is unequal between these sides, the pool is 'skewed' which results in the swap agreement creating polarised leverage.
+This skew can be "farmed" to extract value such that the tokens aquired bring skew back to the threshold target value (1).
+
+## Example
+Consider the following example: 
+
+3X-Long-BTC pool currently has 2,000,000 usdc in the long pool, and 4,200,000 in the short pool. At the next rebalance, price appreciates, and therefore, short token balance will be paying the long sided pool at a rate higher than 3X, such is the effect of skew. In this example, a skew of 2.1 exists, a skew farmer would find the optimal consumption rate of long tokens to acquire **while a skew exists** that brings this value back to 1.
+
+On disposal, the long sided tokens can be redeemed for an amount higher than the expected amount of usdc, due to the effects of skew. 
\ No newline at end of file
diff --git a/docs/Vault.md b/docs/Vault.md
new file mode 100644
index 0000000..e36205f
--- /dev/null
+++ b/docs/Vault.md
@@ -0,0 +1,20 @@
+### Vault
+This outlines the specification for the ERC4626 compliant vault. Further information regarding ERC4626 vaults can be found in (EIP-4626)[https://eips.ethereum.org/EIPS/eip-4626].
+
+## Spec
+`underlying` The underlying ERC20 principle asset
+
+`longFarmer` The contract responsible for tracking skew state
+
+`Threshold` The threshold skew value
+
+`longFarmer.swap()` Allows swaps from EOA's when skew > Threshold. Users can swap Longtokens for USDC at current price, without slippage or commitment windows. 
+
+## User Flow
+Users deposit USDC `underlying` into the Vault. 
+
+Users recieve vAsset tokens, a tokenised representation of their vault position, ie. `shares`.
+
+Vault hands off skew watch conditions to longFarmer, who puts the vault into an `Active` state when a skew exists. 
+
+Users can withdraw USDC from the vault by calling `Withdraw`
diff --git a/lib/openzeppelin-contracts b/lib/openzeppelin-contracts
index 5a75065..c12076f 160000
--- a/lib/openzeppelin-contracts
+++ b/lib/openzeppelin-contracts
@@ -1 +1 @@
-Subproject commit 5a75065659a65e65bb04890192e3a4bcb7917fff
+Subproject commit c12076fb7e3dfe48ef1d9c3bb2a58bdd3ffc0cee
diff --git a/lib/solmate b/lib/solmate
index 9f16db2..b86fbec 160000
--- a/lib/solmate
+++ b/lib/solmate
@@ -1 +1 @@
-Subproject commit 9f16db2144cc9a7e2ffc5588d4bf0b66784283bd
+Subproject commit b86fbec6469f4aa4f8e52aaf62bbfd6940d7008f

From f3c487cd42a9ba134fc154a91f2e3a09b27f5354 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 11:08:09 +1000
Subject: [PATCH 32/45] lint

---
 contracts/LongFarmer.sol | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/contracts/LongFarmer.sol b/contracts/LongFarmer.sol
index edaf725..c31cb74 100644
--- a/contracts/LongFarmer.sol
+++ b/contracts/LongFarmer.sol
@@ -199,7 +199,7 @@ contract LongFarmer is Ownable {
      * @dev only call when swaps cant fulfil wants
      * @param _amount amount of long tokens to be aquired
      */
-    function acquire(uint256 _amount) public onlyWhitelist{
+    function acquire(uint256 _amount) public onlyWhitelist {
         require(state == State.Active, "vault must be active to acquire");
         require(tradingStats.unWinding == false, "vault must be aquiring not unwinding");
         require(skew() > threshold, "pools must be skewed to acquire");
@@ -311,7 +311,7 @@ contract LongFarmer is Ownable {
         _;
     }
     modifier onlyWhitelist() {
-        require(skewVault.whiteList(msg.sender)  == true, "Only whitelisted accounts can execute");
+        require(skewVault.whiteList(msg.sender) == true, "Only whitelisted accounts can execute");
         _;
     }
 }

From cdcb0847a5b1f79e917e0f884db6169d223d526a Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 11:13:07 +1000
Subject: [PATCH 33/45] git submodules fix

---
 .gitmodules   | 3 +++
 docs/Vault.md | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/.gitmodules b/.gitmodules
index 613161c..0765db8 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -31,3 +31,6 @@
 [submodule "lib/foundry-playground"]
 	path = lib/foundry-playground
 	url = https://github.com/dekz/foundry-playground
+[submodule "lib/foundry-playground/lib/ds-test"]
+	path = lib/foundry-playground/lib/ds-test
+	url = https://github.com/dekz/foundry-playground/tree/master/lib/ds-test
diff --git a/docs/Vault.md b/docs/Vault.md
index e36205f..be709ea 100644
--- a/docs/Vault.md
+++ b/docs/Vault.md
@@ -1,5 +1,5 @@
 ### Vault
-This outlines the specification for the ERC4626 compliant vault. Further information regarding ERC4626 vaults can be found in (EIP-4626)[https://eips.ethereum.org/EIPS/eip-4626].
+This outlines the specification for the ERC4626 compliant vault. Further information regarding ERC4626 vaults can be found in [EIP-4626](https://eips.ethereum.org/EIPS/eip-4626).
 
 ## Spec
 `underlying` The underlying ERC20 principle asset

From 3ce11e49b7b34d2ada84de68709a7c5bd1ee93ca Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 11:16:18 +1000
Subject: [PATCH 34/45] submodule paths

---
 .gitmodules | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitmodules b/.gitmodules
index 0765db8..40f097e 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -31,6 +31,6 @@
 [submodule "lib/foundry-playground"]
 	path = lib/foundry-playground
 	url = https://github.com/dekz/foundry-playground
-[submodule "lib/foundry-playground/lib/ds-test"]
+[submodule "lib/foundry-playground"]
 	path = lib/foundry-playground/lib/ds-test
 	url = https://github.com/dekz/foundry-playground/tree/master/lib/ds-test

From 22be627b821ad5df6330f57c9ba93145bc95dbc0 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 11:18:40 +1000
Subject: [PATCH 35/45] workflows

---
 .github/workflows/main.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 51c178c..7990d15 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -19,7 +19,7 @@ jobs:
               run: yarn install
 
             - name: Install submodules
-              run: git submodule update --init --recursive
+              run: forge install
 
             - name: Compile contracts
               run: yarn build
@@ -46,7 +46,7 @@ jobs:
               run: yarn install
               
             - name: Install submodules
-              run: git submodule update --init --recursive
+              run: forge install
 
             - name: Compile contracts
               run: yarn build

From f289c0e7180624bd78a7cc0554ae21316ad6a9a5 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 11:21:49 +1000
Subject: [PATCH 36/45] workflows

---
 .github/workflows/main.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 7990d15..51c178c 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -19,7 +19,7 @@ jobs:
               run: yarn install
 
             - name: Install submodules
-              run: forge install
+              run: git submodule update --init --recursive
 
             - name: Compile contracts
               run: yarn build
@@ -46,7 +46,7 @@ jobs:
               run: yarn install
               
             - name: Install submodules
-              run: forge install
+              run: git submodule update --init --recursive
 
             - name: Compile contracts
               run: yarn build

From e45e71c14e1be1964af9e541c0d0dac55fe9f45d Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 11:25:15 +1000
Subject: [PATCH 37/45] submodules

---
 .gitmodules | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/.gitmodules b/.gitmodules
index 40f097e..613161c 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -31,6 +31,3 @@
 [submodule "lib/foundry-playground"]
 	path = lib/foundry-playground
 	url = https://github.com/dekz/foundry-playground
-[submodule "lib/foundry-playground"]
-	path = lib/foundry-playground/lib/ds-test
-	url = https://github.com/dekz/foundry-playground/tree/master/lib/ds-test

From b2f731b804556a84da05c734534b189d2c1d47c8 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 11:27:10 +1000
Subject: [PATCH 38/45] modules

---
 test/SkewVault.t.sol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/SkewVault.t.sol b/test/SkewVault.t.sol
index 0d083f0..c34cd2f 100644
--- a/test/SkewVault.t.sol
+++ b/test/SkewVault.t.sol
@@ -19,7 +19,7 @@ interface Cheats {
     function prank(address) external;
 }
 
-contract SkewVaulttest is DSTest, ERC20TokenFaker {
+contract SkewVaulttest is DSTest {
     using SafeMath for uint256;
     LongFarmer longFarmer;
     SkewVault skewVault;

From acec708207c35e72c7cc521de0d044993ff65ade Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 11:31:13 +1000
Subject: [PATCH 39/45] modules

---
 .gitmodules | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/.gitmodules b/.gitmodules
index 613161c..4599483 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,8 +1,8 @@
 [submodule "lib/solmate"]
 	path = lib/solmate
 	url = https://github.com/Rari-Capital/solmate
-[submodule "forge/lib/ds-test"]
-	path = forge/lib/ds-test
+[submodule "lib/ds-test"]
+	path = lib/ds-test
 	url = https://github.com/dapphub/ds-test
 [submodule "forge/lib/solmate"]
 	path = forge/lib/solmate
@@ -10,13 +10,13 @@
 [submodule "forge/lib/perpetual-pools-contracts"]
 	path = forge/lib/perpetual-pools-contracts
 	url = https://github.com/tracer-protocol/perpetual-pools-contracts
-[submodule "forge/lib/abdk-libraries-solidity"]
-	path = forge/lib/abdk-libraries-solidity
+[submodule "lib/abdk-libraries-solidity"]
+	path = lib/abdk-libraries-solidity
 	url = https://github.com/abdk-consulting/abdk-libraries-solidity
-[submodule "forge/lib/openzeppelin-contracts"]
+[submodule "lib/openzeppelin-contracts"]
 	path = forge/lib/openzeppelin-contracts
 	url = https://github.com/openzeppelin/openzeppelin-contracts
-[submodule "forge/lib/forge-std"]
+[submodule "lib/forge-std"]
 	path = forge/lib/forge-std
 	url = https://github.com/brockelmore/forge-std
 [submodule "lib/openzeppelin-contracts"]
@@ -25,9 +25,6 @@
 [submodule "lib/perpetual-pools-contracts"]
 	path = lib/perpetual-pools-contracts
 	url = https://github.com/tracer-protocol/perpetual-pools-contracts
-[submodule "lib/ds-test"]
-	path = lib/ds-test
-	url = https://github.com/dapphub/ds-test
 [submodule "lib/foundry-playground"]
 	path = lib/foundry-playground
 	url = https://github.com/dekz/foundry-playground

From ee77a201c2d25d1e191c419b8e86a6362dc0f5b1 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 11:39:13 +1000
Subject: [PATCH 40/45] remove foundry-playground

---
 .gitmodules                    |   3 -
 lib/foundry-playground         |   1 -
 test/interfaces/IVM.sol        |  99 +++++++++++++++
 test/utils/ERC20TokenFaker.sol |  39 ++++++
 test/utils/FakeERC20.sol       | 225 +++++++++++++++++++++++++++++++++
 5 files changed, 363 insertions(+), 4 deletions(-)
 delete mode 160000 lib/foundry-playground
 create mode 100644 test/interfaces/IVM.sol
 create mode 100644 test/utils/ERC20TokenFaker.sol
 create mode 100644 test/utils/FakeERC20.sol

diff --git a/.gitmodules b/.gitmodules
index 4599483..a372e3a 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -25,6 +25,3 @@
 [submodule "lib/perpetual-pools-contracts"]
 	path = lib/perpetual-pools-contracts
 	url = https://github.com/tracer-protocol/perpetual-pools-contracts
-[submodule "lib/foundry-playground"]
-	path = lib/foundry-playground
-	url = https://github.com/dekz/foundry-playground
diff --git a/lib/foundry-playground b/lib/foundry-playground
deleted file mode 160000
index ae18323..0000000
--- a/lib/foundry-playground
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit ae18323cbf6696e000e0770b6137f60842232411
diff --git a/test/interfaces/IVM.sol b/test/interfaces/IVM.sol
new file mode 100644
index 0000000..efc5472
--- /dev/null
+++ b/test/interfaces/IVM.sol
@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.10;
+
+interface IVm {
+    // Set block.timestamp
+    function warp(uint256) external;
+
+    // Set block.number
+    function roll(uint256) external;
+
+    // Set block.basefee
+    function fee(uint256) external;
+
+    // Loads a storage slot from an address
+    function load(address account, bytes32 slot) external returns (bytes32);
+
+    // Stores a value to an address' storage slot
+    function store(
+        address account,
+        bytes32 slot,
+        bytes32 value
+    ) external;
+
+    // Signs data
+    function sign(uint256 privateKey, bytes32 digest)
+        external
+        returns (
+            uint8 v,
+            bytes32 r,
+            bytes32 s
+        );
+
+    // Computes address for a given private key
+    function addr(uint256 privateKey) external returns (address);
+
+    // Performs a foreign function call via terminal
+    function ffi(string[] calldata) external returns (bytes memory);
+
+    // Sets the *next* call's msg.sender to be the input address
+    function prank(address) external;
+
+    // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
+    function startPrank(address) external;
+
+    // Sets the *next* call's msg.sender to be the input address, and the tx.origin to be the second input
+    function prank(address, address) external;
+
+    // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called, and the tx.origin to be the second input
+    function startPrank(address, address) external;
+
+    // Resets subsequent calls' msg.sender to be `address(this)`
+    function stopPrank() external;
+
+    // Sets an address' balance
+    function deal(address who, uint256 newBalance) external;
+
+    // Sets an address' code
+    function etch(address who, bytes calldata code) external;
+
+    // Expects an error on next call
+    function expectRevert(bytes calldata) external;
+
+    function expectRevert(bytes4) external;
+
+    // Record all storage reads and writes
+    function record() external;
+
+    // Gets all accessed reads and write slot from a recording session, for a given address
+    function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
+
+    // Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData).
+    // Call this function, then emit an event, then call a function. Internally after the call, we check if
+    // logs were emitted in the expected order with the expected topics and data (as specified by the booleans)
+    function expectEmit(
+        bool,
+        bool,
+        bool,
+        bool
+    ) external;
+
+    // Mocks a call to an address, returning specified data.
+    // Calldata can either be strict or a partial match, e.g. if you only
+    // pass a Solidity selector to the expected calldata, then the entire Solidity
+    // function will be mocked.
+    function mockCall(
+        address,
+        bytes calldata,
+        bytes calldata
+    ) external;
+
+    // Clears all mocked calls
+    function clearMockedCalls() external;
+
+    // Expect a call to an address with the specified calldata.
+    // Calldata can either be strict or a partial match
+    function expectCall(address, bytes calldata) external;
+
+    function getCode(string calldata) external returns (bytes memory);
+}
diff --git a/test/utils/ERC20TokenFaker.sol b/test/utils/ERC20TokenFaker.sol
new file mode 100644
index 0000000..eab7e3e
--- /dev/null
+++ b/test/utils/ERC20TokenFaker.sol
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+import "../interfaces/IVM.sol";
+import "./FakeERC20.sol";
+
+abstract contract ERC20TokenFaker {
+    FakeERC20 FAKE = new FakeERC20();
+    IVm VM = IVm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
+
+    function fakeOutERC20(address token) internal returns (FakeERC20 fakedToken) {
+        fakeOut(token, address(FAKE).code);
+        fakedToken = FakeERC20(payable(token));
+    }
+
+    function unfakeERC20(address token) internal {
+        unfake(token);
+    }
+
+    function fakeOut(address orig, bytes memory code) private {
+        // Move the original code to a new address
+        address moved = movedAddress(orig);
+        VM.etch(moved, orig.code);
+
+        // Replace code with faked implementation
+        VM.etch(orig, code);
+    }
+
+    function unfake(address addr) private {
+        address moved = movedAddress(addr);
+        if (addr.code.length != 0) {
+            VM.etch(addr, moved.code);
+        }
+    }
+
+    function movedAddress(address orig) private returns (address moved) {
+        moved = address(uint160(address(orig)) + 1);
+    }
+}
diff --git a/test/utils/FakeERC20.sol b/test/utils/FakeERC20.sol
new file mode 100644
index 0000000..dda6554
--- /dev/null
+++ b/test/utils/FakeERC20.sol
@@ -0,0 +1,225 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.10;
+
+interface IERC20 {
+    function allowance(address owner, address spender) external returns (uint256);
+
+    function balanceOf(address owner) external returns (uint256);
+}
+
+contract FakeERC20 {
+    struct ShadowedAmount {
+        bool isShadowed;
+        uint256 lastTrueAmount;
+        uint256 shadowedAmount;
+    }
+
+    struct Storage {
+        mapping(address => ShadowedAmount) shadowedBalances;
+        mapping(address => mapping(address => ShadowedAmount)) shadowedAllowances;
+    }
+
+    bytes32 private constant STORAGE_SLOT = 0x64fd48372774b9637ace5c8c7a951f04ea13c793935207f2eada5382a0ec82cb;
+
+    receive() external payable {}
+
+    fallback() external payable {
+        bytes memory r = _forwardCallToImpl();
+        assembly {
+            return(add(r, 32), mload(r))
+        }
+    }
+
+    function balanceOf(address owner)
+        external
+        returns (
+            /* view */
+            uint256 balance
+        )
+    {
+        ShadowedAmount memory sBal = _getSyncedBalance(owner);
+        return sBal.shadowedAmount;
+    }
+
+    function allowance(address owner, address spender)
+        external
+        returns (
+            /* view */
+            uint256 allowance_
+        )
+    {
+        ShadowedAmount memory sBal = _getSyncedAllowance(owner, spender);
+        return sBal.shadowedAmount;
+    }
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) public returns (bool success) {
+        _updateAllowance(from, amount);
+        success = _transferFromInternal(from, to, amount);
+    }
+
+    function transfer(address to, uint256 amount) external returns (bool success) {
+        success = _transferFromInternal(msg.sender, to, amount);
+    }
+
+    function approve(address spender, uint256 amount) external returns (bool) {
+        ShadowedAmount memory sAllowance = _getSyncedAllowance(msg.sender, spender);
+
+        sAllowance.shadowedAmount = amount;
+        _writeSyncedAllowance(msg.sender, spender, sAllowance);
+
+        return true;
+    }
+
+    function _setBalance(address owner, uint256 amount) public returns (uint256 newBalance) {
+        ShadowedAmount memory sBal = _getSyncedBalance(owner);
+        sBal.shadowedAmount = amount;
+        _writeSyncedBalance(owner, sBal);
+        newBalance = _getStorage().shadowedBalances[owner].shadowedAmount;
+    }
+
+    function _getSyncedAllowance(address owner, address spender)
+        private
+        returns (
+            /* view */
+            ShadowedAmount memory sAllowance
+        )
+    {
+        uint256 trueAmount = abi.decode(
+            _forwardCallToImpl(abi.encodeWithSelector(IERC20.allowance.selector, owner, spender)),
+            (uint256)
+        );
+        // We only want to measure the cost of the underlying token storage lookup
+        // Not including the excess overhead of our shadow lookup
+        sAllowance = _getStorage().shadowedAllowances[owner][spender];
+        _syncShadowedAmount(sAllowance, trueAmount);
+    }
+
+    function _getSyncedBalance(address owner) private returns (ShadowedAmount memory sBal) {
+        uint256 trueAmount = abi.decode(
+            _forwardCallToImpl(abi.encodeWithSelector(IERC20.balanceOf.selector, owner)),
+            (uint256)
+        );
+        // We only want to measure the cost of the underlying token storage lookup
+        // Not including the excess overhead of our shadow lookup
+        sBal = _getStorage().shadowedBalances[owner];
+        _syncShadowedAmount(sBal, trueAmount);
+    }
+
+    function _syncShadowedAmount(ShadowedAmount memory sAmount, uint256 trueAmount) private pure {
+        if (!sAmount.isShadowed) {
+            sAmount.isShadowed = true;
+            sAmount.shadowedAmount = trueAmount;
+        } else {
+            // Detect balance changes that can occur from outside of ERC20
+            // functions.
+            if (sAmount.lastTrueAmount > trueAmount) {
+                sAmount.shadowedAmount = _sub(
+                    sAmount.lastTrueAmount,
+                    sAmount.lastTrueAmount - trueAmount,
+                    "FakeERC20/SHADOW_ADJUSTMENT_UNDERFLOW"
+                );
+            } else if (sAmount.lastTrueAmount < trueAmount) {
+                sAmount.shadowedAmount = _add(
+                    sAmount.lastTrueAmount,
+                    trueAmount - sAmount.lastTrueAmount,
+                    "FakeERC20/SHADOW_ADJUSTMENT_OVERFLOW"
+                );
+            }
+        }
+        sAmount.lastTrueAmount = trueAmount;
+    }
+
+    function _writeSyncedBalance(address owner, ShadowedAmount memory sBal) private {
+        _getStorage().shadowedBalances[owner] = sBal;
+    }
+
+    function _writeSyncedAllowance(
+        address owner,
+        address spender,
+        ShadowedAmount memory sAllowance
+    ) private {
+        _getStorage().shadowedAllowances[owner][spender] = sAllowance;
+    }
+
+    function _getStorage() private pure returns (Storage storage st) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            st.slot := slot
+        }
+    }
+
+    function _getOriginalImplementationAddress() private view returns (address impl) {
+        return address(uint160(address(this)) + 1);
+    }
+
+    function _forwardCallToImpl() private returns (bytes memory resultData) {
+        bool success;
+        (success, resultData) = _getOriginalImplementationAddress().delegatecall(msg.data);
+        if (!success) {
+            assembly {
+                revert(add(resultData, 32), mload(resultData))
+            }
+        }
+    }
+
+    function _forwardCallToImpl(bytes memory callData) private returns (bytes memory resultData) {
+        bool success;
+        (success, resultData) = _getOriginalImplementationAddress().delegatecall(callData);
+        if (!success) {
+            assembly {
+                revert(add(resultData, 32), mload(resultData))
+            }
+        }
+    }
+
+    function _transferFromInternal(
+        address from,
+        address to,
+        uint256 amount
+    ) internal returns (bool) {
+        ShadowedAmount memory sFromBal;
+        ShadowedAmount memory sToBal;
+
+        sFromBal = _getSyncedBalance(from);
+        sFromBal.shadowedAmount = _sub(sFromBal.shadowedAmount, amount, "FakeERC20/BALANCE_UNDERFLOW");
+        _writeSyncedBalance(from, sFromBal);
+
+        sToBal = _getSyncedBalance(to);
+        sToBal.shadowedAmount = _add(sToBal.shadowedAmount, amount, "FakeERC20/BALANCE_OVERFLOW");
+        _writeSyncedBalance(to, sToBal);
+
+        return true;
+    }
+
+    function _updateAllowance(address from, uint256 amount) internal {
+        ShadowedAmount memory sAllowance = _getSyncedAllowance(from, msg.sender);
+        if (from != msg.sender && sAllowance.shadowedAmount != type(uint256).max) {
+            sAllowance.shadowedAmount = _sub(sAllowance.shadowedAmount, amount, "FakeERC20/ALLOWANCE_UNDERFLOW");
+            _writeSyncedAllowance(from, msg.sender, sAllowance);
+        }
+        // Assume a NON MAX_UINT results in allowance update SSTORE
+        _writeSyncedAllowance(from, msg.sender, sAllowance);
+    }
+
+    function _add(
+        uint256 a,
+        uint256 b,
+        string memory errMsg
+    ) private pure returns (uint256 c) {
+        c = a + b;
+        require(c >= a, errMsg);
+    }
+
+    function _sub(
+        uint256 a,
+        uint256 b,
+        string memory errMsg
+    ) private pure returns (uint256 c) {
+        c = a - b;
+        require(c <= a, errMsg);
+    }
+}

From 16f28a7ca7800f98f7cbe660d9129266002fc1b0 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 11:44:40 +1000
Subject: [PATCH 41/45] readme updates

---
 readme.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/readme.md b/readme.md
index 402353e..eb4d4e0 100644
--- a/readme.md
+++ b/readme.md
@@ -1,6 +1,9 @@
 # Tracer Vaults
 WIP Tracer vaults
 
+## Skew Farm Vault
+[Docs](https://github.com/tracer-protocol/tracer-vaults/tree/skew-farm/docs)
+
 ## Getting Started
 This repo currently uses a combination of Foundry and Hardhat. We will eventually migrate exclusively to Foundry, but for now this means a few steps are needed to get things set up.
 

From b4ea38b8946fc39b65c51f48dc64956bea77922c Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 13:26:19 +1000
Subject: [PATCH 42/45] forge install: forge-std

---
 .gitmodules   | 4 ++--
 lib/forge-std | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)
 create mode 160000 lib/forge-std

diff --git a/.gitmodules b/.gitmodules
index a372e3a..8e7ceef 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -17,8 +17,8 @@
 	path = forge/lib/openzeppelin-contracts
 	url = https://github.com/openzeppelin/openzeppelin-contracts
 [submodule "lib/forge-std"]
-	path = forge/lib/forge-std
-	url = https://github.com/brockelmore/forge-std
+	path = lib/forge-std
+	url = https://github.com/foundry-rs/forge-std
 [submodule "lib/openzeppelin-contracts"]
 	path = lib/openzeppelin-contracts
 	url = https://github.com/openzeppelin/openzeppelin-contracts
diff --git a/lib/forge-std b/lib/forge-std
new file mode 160000
index 0000000..bdd321f
--- /dev/null
+++ b/lib/forge-std
@@ -0,0 +1 @@
+Subproject commit bdd321fc4ac81aff81924effb559427fcccca769

From 0e3f30ead7857c75fbd263408fcd9efb2b22498e Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 14:06:42 +1000
Subject: [PATCH 43/45] lints, testing and fixes

---
 contracts/LongFarmer.sol               |    10 +-
 contracts/SkewVault.sol                |    18 +-
 out/LongFarmer.sol/LongFarmer.json     | 14848 ++++++++++++
 out/SkewVault.sol/SkewVault.json       |  3183 +++
 out/SkewVault.t.sol/Cheats.json        |  5137 ++++
 out/SkewVault.t.sol/SkewVaulttest.json |  5399 +++++
 out/Test.sol/Test.json                 | 29291 +++++++++++++++++++++++
 out/Test.sol/stdError.json             | 28796 ++++++++++++++++++++++
 out/Test.sol/stdStorage.json           | 28740 ++++++++++++++++++++++
 out/Vm.sol/Vm.json                     |  2984 +++
 test/SkewVault.t.sol                   |    50 +-
 11 files changed, 118418 insertions(+), 38 deletions(-)
 create mode 100644 out/LongFarmer.sol/LongFarmer.json
 create mode 100644 out/SkewVault.sol/SkewVault.json
 create mode 100644 out/SkewVault.t.sol/Cheats.json
 create mode 100644 out/SkewVault.t.sol/SkewVaulttest.json
 create mode 100644 out/Test.sol/Test.json
 create mode 100644 out/Test.sol/stdError.json
 create mode 100644 out/Test.sol/stdStorage.json
 create mode 100644 out/Vm.sol/Vm.json

diff --git a/contracts/LongFarmer.sol b/contracts/LongFarmer.sol
index c31cb74..8c24f61 100644
--- a/contracts/LongFarmer.sol
+++ b/contracts/LongFarmer.sol
@@ -48,6 +48,7 @@ contract LongFarmer is Ownable {
     bool public tradeLive;
     uint256 public threshold;
     uint256 window;
+    uint256 public depUSDC; //deposited USDC
     ILeveragedPool public pool;
     L2Encoder encoder;
     event unwind(uint256 _amt);
@@ -84,6 +85,7 @@ contract LongFarmer is Ownable {
             address(0xC3d2052479dBC010480Ae16204777C1469CEffC9),
             0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
         );
+        longToken.approve(address(this), 1e18);
     }
 
     /**
@@ -199,13 +201,13 @@ contract LongFarmer is Ownable {
      * @dev only call when swaps cant fulfil wants
      * @param _amount amount of long tokens to be aquired
      */
-    function acquire(uint256 _amount) public onlyWhitelist {
+    function acquire(uint256 _amount) public {
         require(state == State.Active, "vault must be active to acquire");
         require(tradingStats.unWinding == false, "vault must be aquiring not unwinding");
         require(skew() > threshold, "pools must be skewed to acquire");
         require(tradingStats.stopping != true, "next skew under threshold");
         USDC.approve(
-            address(0xC3d2052479dBC010480Ae16204777C1469CEffC9),
+            address(0xccC0350C209F6F01D071c3cdc20eEb5EE4A73d80),
             0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
         );
         tradingStats.swapping = false;
@@ -254,7 +256,6 @@ contract LongFarmer is Ownable {
         require(state == State.Active, "Vault is not active");
         require(tradingStats.unWinding == false, "Vault is unwinding");
         require(tradingStats.swapping == true, "Vault is not swapping");
-        longToken.approve(address(this), 1e18);
         longToken.transferFrom(address(msg.sender), address(this), _amtLong);
         uint256 _out = longTokenPrice().mul(_amtLong);
         ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).transfer(address(msg.sender), _out);
@@ -294,7 +295,8 @@ contract LongFarmer is Ownable {
     }
 
     function rxFunds(uint256 _amt) public {
-        USDC.transferFrom(address(vault), address(this), _amt);
+        USDC.transferFrom(address(skewVault), address(this), _amt);
+        depUSDC += _amt;
     }
 
     function returnFunds(uint256 amount) public {
diff --git a/contracts/SkewVault.sol b/contracts/SkewVault.sol
index 2919d33..a335d23 100644
--- a/contracts/SkewVault.sol
+++ b/contracts/SkewVault.sol
@@ -20,16 +20,10 @@ contract SkewVault is ERC4626, Ownable {
 
     mapping(address => bool) public whiteList;
 
-    constructor(
-        address _underlying,
-        address pooladdr,
-        uint256 _threshold,
-        address _committer,
-        address _encoder
-    ) ERC4626(ERC20(_underlying), "TracerVault", "TVLT") {
+    constructor(address _underlying) ERC4626(ERC20(_underlying), "TracerVault", "TVLT") {
         underlying = ERC20(_underlying);
-        longFarmer = new LongFarmer();
-        longFarmer.initialize(pooladdr, _threshold, _committer, _encoder, ERC20(this));
+        // longFarmer = new LongFarmer();
+        // longFarmer.initialize(pooladdr, _threshold, _committer, _encoder, ERC20(this));
     }
 
     function totalAssets() public view override returns (uint256) {
@@ -54,10 +48,8 @@ contract SkewVault is ERC4626, Ownable {
 
     function afterDeposit(uint256 assets, uint256 shares) internal virtual override {
         require(whiteList[msg.sender] == true);
-
-        // longFarmer.rxFunds(assets);
-        // // underlying.safeTransferFrom(address(this), address(longFarmer), assets);
-        underlying.safeTransfer(address(longFarmer), assets);
+        // underlying.safeTransfer(address(longFarmer), assets);
+        longFarmer.rxFunds(assets);
     }
 
     function beforeWithdraw(uint256 assets, uint256 shares) internal virtual override {
diff --git a/out/LongFarmer.sol/LongFarmer.json b/out/LongFarmer.sol/LongFarmer.json
new file mode 100644
index 0000000..5957878
--- /dev/null
+++ b/out/LongFarmer.sol/LongFarmer.json
@@ -0,0 +1,14848 @@
+{
+    "abi": [
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "_msg",
+                    "type": "string"
+                }
+            ],
+            "name": "Log",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "previousOwner",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "newOwner",
+                    "type": "address"
+                }
+            ],
+            "name": "OwnershipTransferred",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "_amt",
+                    "type": "uint256"
+                }
+            ],
+            "name": "acquired",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "_amt",
+                    "type": "uint256"
+                }
+            ],
+            "name": "unwind",
+            "type": "event"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "_amtLong",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "_minAmtUSDC",
+                    "type": "uint256"
+                }
+            ],
+            "name": "_swap",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "_amount",
+                    "type": "uint256"
+                }
+            ],
+            "name": "acquire",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "_amt",
+                    "type": "uint256"
+                }
+            ],
+            "name": "agBal",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "depUSDC",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "_amount",
+                    "type": "uint256"
+                }
+            ],
+            "name": "dispose",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "_poolAddress",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "_threshold",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "address",
+                    "name": "_committer",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "_encoder",
+                    "type": "address"
+                },
+                {
+                    "internalType": "contract ERC20",
+                    "name": "_vault",
+                    "type": "address"
+                }
+            ],
+            "name": "initialize",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "longTokenPrice",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "_rate",
+                    "type": "uint256"
+                }
+            ],
+            "name": "nextSkew",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "owner",
+            "outputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "poke",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "pool",
+            "outputs": [
+                {
+                    "internalType": "contract ILeveragedPool",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "renounceOwnership",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "amount",
+                    "type": "uint256"
+                }
+            ],
+            "name": "returnFunds",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "_amt",
+                    "type": "uint256"
+                }
+            ],
+            "name": "rxFunds",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "setActive",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "_vault",
+                    "type": "address"
+                }
+            ],
+            "name": "setSkewVault",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "skew",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "_rate",
+                    "type": "uint256"
+                }
+            ],
+            "name": "target",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "threshold",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "tradeLive",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "newOwner",
+                    "type": "address"
+                }
+            ],
+            "name": "transferOwnership",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "value",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        }
+    ],
+    "bytecode": {
+        "object": "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",
+        "sourceMap": "1078:11241:0:-:0;;;;;;;;;;;;-1:-1:-1;921:32:6;719:10:12;921:18:6;:32::i;:::-;1078:11241:0;;2270:187:6;2343:16;2362:6;;-1:-1:-1;;;;;2378:17:6;;;-1:-1:-1;;;;;;2378:17:6;;;;;;2410:40;;2362:6;;;;;;;2410:40;;2343:16;2410:40;2333:124;2270:187;:::o;1078:11241:0:-;;;;;;;",
+        "linkReferences": {}
+    },
+    "deployedBytecode": {
+        "object": "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",
+        "sourceMap": "1078:11241:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11003:268;;;:::i;:::-;;;160:25:23;;;148:2;133:18;11003:268:0;;;;;;;;11504:170;;;;;;:::i;:::-;;:::i;:::-;;1975:26;;;;;-1:-1:-1;;;;;1975:26:0;;;;;;-1:-1:-1;;;;;771:32:23;;;753:51;;741:2;726:18;1975:26:0;584:226:23;4187:2149:0;;;:::i;:::-;;;980:14:23;;973:22;955:41;;943:2;928:18;4187:2149:0;815:187:23;1930:22:0;;;;;;7768:975;;;;;;:::i;:::-;;:::i;11680:138::-;;;;;;:::i;:::-;;:::i;3558:327::-;;;:::i;1880:24::-;;;;;;11824:102;;;;;;:::i;:::-;;:::i;9484:503::-;;;;;;:::i;:::-;;:::i;10230:662::-;;;;;;:::i;:::-;;:::i;1668:101:6:-;;;:::i;11348:150:0:-;;;:::i;1036:85:6:-;1082:7;1108:6;-1:-1:-1;;;;;1108:6:6;1036:85;;6781:274:0;;;;;;:::i;:::-;;:::i;7230:335::-;;;;;;:::i;:::-;;:::i;2125:1298::-;;;;;;:::i;:::-;;:::i;1853:21::-;;;;;-1:-1:-1;;;1853:21:0;;;;;;6425:240;;;:::i;8968:255::-;;;;;;:::i;:::-;;:::i;1918:198:6:-;;;;;;:::i;:::-;;:::i;11003:268:0:-;11050:7;11069:11;11083:4;;;;;;;;;-1:-1:-1;;;;;11083:4:0;-1:-1:-1;;;;;11083:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11069:32;;11111:13;11127:32;11135:9;;;;;;;;;-1:-1:-1;;;;;11135:9:0;-1:-1:-1;;;;;11135:21:0;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11127:3;;:7;:32::i;:::-;11111:48;-1:-1:-1;11173:10:0;11169:96;;11206:5;11199:12;;;;11003:268;:::o;11169:96::-;11249:5;11003:268;-1:-1:-1;;11003:268:0:o;11504:170::-;11559:9;:29;;-1:-1:-1;;;;;11559:29:0;;;-1:-1:-1;;;;;;11559:29:0;;;;;;;;11598:5;:21;;;;;;;;;;11629:4;;:38;;-1:-1:-1;;;11629:38:0;;;;;2801:51:23;;;;11662:4:0;2868:18:23;;;2861:34;11629:4:0;;:12;;2774:18:23;;11629:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;11504:170;:::o;4187:2149::-;4219:4;4252:15;4243:6;;:24;4235:67;;;;-1:-1:-1;;;4235:67:0;;3390:2:23;4235:67:0;;;3372:21:23;3429:2;3409:18;;;3402:30;3468:32;3448:18;;;3441:60;3518:18;;4235:67:0;;;;;;;;;4312:12;4327:48;4358:16;:14;:16::i;:::-;4327:26;;;:30;:48::i;:::-;4312:63;;4385:13;4401:6;:4;:6::i;:::-;4385:22;;4417:10;4457:9;;4449:5;:17;:42;;;;-1:-1:-1;4479:12:0;4470:5;;-1:-1:-1;;;4470:5:0;;;;:21;;;;;;;;:::i;:::-;;;4449:42;4445:436;;;4507:5;:20;;-1:-1:-1;;;;4507:20:0;-1:-1:-1;;;4507:20:0;;;4541:22;:30;;;4610:15;-1:-1:-1;4585:40:0;4657:12;4664:4;4657:6;:12::i;:::-;4683:22;:32;-1:-1:-1;;4729:21:0;:28;;-1:-1:-1;;4815:29:0;4683:12;4815:29;;;;;;4445:436;4903:12;4894:5;;-1:-1:-1;;;4894:5:0;;;;:21;;;;;;;;:::i;:::-;;:42;;;;;4927:9;;4919:5;:17;4894:42;:70;;;;-1:-1:-1;4940:20:0;;:24;;4894:70;4890:429;;;4999:20;;4980:16;5051:12;5058:4;5051:6;:12::i;:::-;5033:30;-1:-1:-1;5077:13:0;5093:21;5033:30;5105:8;5093:11;:21::i;:::-;5128:17;:25;-1:-1:-1;;5167:21:0;:28;;-1:-1:-1;;5253:29:0;5128:12;5253:29;;;;;;5128:12;-1:-1:-1;;4890:429:0;5344:5;5332:9;;:17;5328:495;;;5439:13;;:48;;-1:-1:-1;;;5439:48:0;;5481:4;5439:48;;;753:51:23;5365:15:0;;5383:129;;-1:-1:-1;;;;;5439:13:0;;;;:33;;726:18:23;;5439:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:59;5383:9;;:34;;-1:-1:-1;;;5383:34:0;;5411:4;5383:34;;;753:51:23;-1:-1:-1;;;;;5383:9:0;;;;:19;;726:18:23;;5383:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:38;;:129::i;:::-;5541:7;;:84;;-1:-1:-1;;;5541:84:0;;5365:147;;-1:-1:-1;5526:12:0;;-1:-1:-1;;;;;5541:7:0;;;;:26;;:84;;5365:147;;5577:34;;5526:12;;5541:7;;:84;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5639:13;;:26;;-1:-1:-1;;;5639:26:0;;;;;160:25:23;;;5526:99:0;;-1:-1:-1;;;;;;5639:13:0;;:20;;133:18:23;;5639:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5684:15;5691:7;5684:15;;;;160:25:23;;148:2;133:18;;14:177;5684:15:0;;;;;;;;-1:-1:-1;;5713:22:0;:29;;-1:-1:-1;;5756:29:0;5713;5756;;;-1:-1:-1;5713:29:0;5328:495;5853:9;;5836:14;5845:4;5836:8;:14::i;:::-;:26;5832:193;;;5878:21;:29;;-1:-1:-1;;5921:28:0;;;;;5968:19;;;;;;5496:2:23;5478:21;;;5535:2;5515:18;;;5508:30;-1:-1:-1;;;5569:2:23;5554:18;;5547:42;5621:2;5606:18;;5294:336;5968:19:0;;;;;;;;-1:-1:-1;6009:5:0;5832:193;6039:18;;;;;5837:2:23;5819:21;;;5876:2;5856:18;;;5849:30;-1:-1:-1;;;5910:2:23;5895:18;;5888:41;5961:2;5946:18;;5635:335;6039:18:0;;;;;;;;6076:22;:15;6094:4;6076:22;:::i;:::-;6067:6;:31;6183:13;;:48;;-1:-1:-1;;;6183:48:0;;6225:4;6183:48;;;753:51:23;6131:121:0;;-1:-1:-1;;;;;6183:13:0;;:33;;726:18:23;;6183:48:0;584:226:23;6131:121:0;6108:20;:144;6291:16;:14;:16::i;:::-;6262:26;:45;6324:5;4187:2149;-1:-1:-1;;;4187:2149:0:o;7768:975::-;7836:12;7827:5;;-1:-1:-1;;;7827:5:0;;;;:21;;;;;;;;:::i;:::-;;7819:65;;;;-1:-1:-1;;;7819:65:0;;6442:2:23;7819:65:0;;;6424:21:23;6481:2;6461:18;;;6454:30;6520:33;6500:18;;;6493:61;6571:18;;7819:65:0;6240:355:23;7819:65:0;7902:22;;;;;;;:31;7894:80;;;;-1:-1:-1;;;7894:80:0;;6802:2:23;7894:80:0;;;6784:21:23;6841:2;6821:18;;;6814:30;6880:34;6860:18;;;6853:62;-1:-1:-1;;;6931:18:23;;;6924:34;6975:19;;7894:80:0;6600:400:23;7894:80:0;8001:9;;7992:6;:4;:6::i;:::-;:18;7984:62;;;;-1:-1:-1;;;7984:62:0;;7207:2:23;7984:62:0;;;7189:21:23;7246:2;7226:18;;;7219:30;7285:33;7265:18;;;7258:61;7336:18;;7984:62:0;7005:355:23;7984:62:0;8064:21;;;;;;;;:29;;:12;:29;;8056:67;;;;-1:-1:-1;;;8056:67:0;;7567:2:23;8056:67:0;;;7549:21:23;7606:2;7586:18;;;7579:30;7645:27;7625:18;;;7618:55;7690:18;;8056:67:0;7365:349:23;8056:67:0;8133:4;;:167;;-1:-1:-1;;;8133:167:0;;8167:42;8133:167;;;2801:51:23;-1:-1:-1;;2868:18:23;;;2861:34;-1:-1:-1;;;;;8133:4:0;;;;:12;;2774:18:23;;8133:167:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;8310:21:0;:29;;-1:-1:-1;;8310:29:0;;;8364:7;;:84;;-1:-1:-1;;;8364:84:0;;8334:5;;-1:-1:-1;;;;;8364:7:0;;:26;;:84;;8391:7;;8400:34;;8334:5;;8310:12;;:21;8364:84;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;8458:13;;:26;;-1:-1:-1;;;8458:26:0;;;;;160:25:23;;;8349:99:0;;-1:-1:-1;;;;;;8458:13:0;;:20;;133:18:23;;8458:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8499:17;8508:7;8499:17;;;;160:25:23;;148:2;133:18;;14:177;8499:17:0;;;;;;;;8549:20;;:33;;8574:7;8549:24;:33::i;:::-;8526:20;:56;8612:17;;:30;;8634:7;8612:21;:30::i;:::-;8592:17;:50;;;8652:84;;8707:21;:29;;-1:-1:-1;;8707:29:0;;;7809:934;7768:975;:::o;8652:84::-;-1:-1:-1;;8676:21:0;:28;;-1:-1:-1;;8676:28:0;8700:4;8676:28;;;7768:975::o;11680:138::-;11728:4;;11754:9;;11728:58;;-1:-1:-1;;;11728:58:0;;-1:-1:-1;;;;;11754:9:0;;;11728:58;;;8323:34:23;11774:4:0;8373:18:23;;;8366:43;8425:18;;;8418:34;;;11728:4:0;;;:17;;8258:18:23;;11728:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;11807:4;11796:7;;:15;;;;;;;:::i;:::-;;;;-1:-1:-1;;;11680:138:0:o;3558:327::-;3633:74;;-1:-1:-1;;;3633:74:0;;3701:4;3633:74;;;753:51:23;3596:7:0;;;;3639:42;;3633:59;;726:18:23;;3633:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3615:92;-1:-1:-1;3730:12:0;3721:5;;-1:-1:-1;;;3721:5:0;;;;:21;;;;;;;;:::i;:::-;;3717:138;;;3758:12;3773:42;3798:16;:14;:16::i;:::-;3773:20;;;:24;:42::i;:::-;3758:57;-1:-1:-1;3829:15:0;3758:57;3829:15;;:::i;:::-;;;3744:111;3717:138;3871:7;3558:327;-1:-1:-1;3558:327:0:o;11824:102::-;11878:4;;11900:9;;11878:41;;-1:-1:-1;;;11878:41:0;;-1:-1:-1;;;;;11900:9:0;;;11878:41;;;2801:51:23;2868:18;;;2861:34;;;11878:4:0;;;:13;;2774:18:23;;11878:41:0;2601:300:23;9484:503:0;11972:5;;:36;;-1:-1:-1;;;11972:36:0;;11996:10;11972:36;;;753:51:23;12011:1:0;;-1:-1:-1;;;;;11972:5:0;;:15;;726:18:23;;11972:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:40;11964:76;;;;-1:-1:-1;;;11964:76:0;;8944:2:23;11964:76:0;;;8926:21:23;8983:2;8963:18;;;8956:30;9022:25;9002:18;;;8995:53;9065:18;;11964:76:0;8742:347:23;11964:76:0;9563:12:::1;9554:5;::::0;-1:-1:-1;;;9554:5:0;::::1;;;:21;::::0;::::1;;;;;;:::i;:::-;;9546:65;;;::::0;-1:-1:-1;;;9546:65:0;;9296:2:23;9546:65:0::1;::::0;::::1;9278:21:23::0;9335:2;9315:18;;;9308:30;9374:33;9354:18;;;9347:61;9425:18;;9546:65:0::1;9094:355:23::0;9546:65:0::1;9636:7;::::0;:85:::1;::::0;-1:-1:-1;;;9636:85:0;;9621:12:::1;::::0;-1:-1:-1;;;;;9636:7:0::1;::::0;:26:::1;::::0;:85:::1;::::0;9663:7;;9672:34:::1;::::0;9621:12;;;;9636:85:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9731:13;::::0;:26:::1;::::0;-1:-1:-1;;;9731:26:0;;::::1;::::0;::::1;160:25:23::0;;;9621:100:0;;-1:-1:-1;;;;;;9731:13:0::1;::::0;:20:::1;::::0;133:18:23;;9731:26:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;9787:17:0;;:30:::1;::::0;-1:-1:-1;9787:17:0;-1:-1:-1;9809:7:0;9787:21:::1;:30::i;:::-;9767:17:::0;:50;:17:::1;9850:20:::0;:33:::1;::::0;9875:7;9850:24:::1;:33::i;:::-;9827:20:::0;:56;9893:17;;9913:4:::1;-1:-1:-1::0;9893:87:0::1;;9951:21:::0;:29;;-1:-1:-1;;9951:29:0::1;::::0;;7809:934;7768:975;:::o;10230:662::-;10315:7;12117:9;;12108:6;:4;:6::i;:::-;:18;12100:52;;;;-1:-1:-1;;;12100:52:0;;9656:2:23;12100:52:0;;;9638:21:23;9695:2;9675:18;;;9668:30;-1:-1:-1;;;9714:18:23;;;9707:51;9775:18;;12100:52:0;9454:345:23;12100:52:0;10351:12:::1;10342:5;::::0;-1:-1:-1;;;10342:5:0;::::1;;;:21;::::0;::::1;;;;;;:::i;:::-;;10334:53;;;::::0;-1:-1:-1;;;10334:53:0;;10006:2:23;10334:53:0::1;::::0;::::1;9988:21:23::0;10045:2;10025:18;;;10018:30;-1:-1:-1;;;10064:18:23;;;10057:49;10123:18;;10334:53:0::1;9804:343:23::0;10334:53:0::1;10405:22:::0;;::::1;::::0;::::1;;;:31;10397:62;;;::::0;-1:-1:-1;;;10397:62:0;;10354:2:23;10397:62:0::1;::::0;::::1;10336:21:23::0;10393:2;10373:18;;;10366:30;-1:-1:-1;;;10412:18:23;;;10405:48;10470:18;;10397:62:0::1;10152:342:23::0;10397:62:0::1;10477:21:::0;;::::1;;:29;;:12;:29;10469:63;;;::::0;-1:-1:-1;;;10469:63:0;;10701:2:23;10469:63:0::1;::::0;::::1;10683:21:23::0;10740:2;10720:18;;;10713:30;-1:-1:-1;;;10759:18:23;;;10752:51;10820:18;;10469:63:0::1;10499:345:23::0;10469:63:0::1;10542:9;::::0;:38:::1;::::0;-1:-1:-1;;;10542:38:0;;10568:4:::1;10542:38;::::0;::::1;2801:51:23::0;10575:4:0::1;2868:18:23::0;;;2861:34;-1:-1:-1;;;;;10542:9:0;;::::1;::::0;:17:::1;::::0;2774:18:23;;10542:38:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;10590:9:0::1;::::0;:68:::1;::::0;-1:-1:-1;;;10590:68:0;;10621:10:::1;10590:68;::::0;::::1;8323:34:23::0;10642:4:0::1;8373:18:23::0;;;8366:43;8425:18;;;8418:34;;;-1:-1:-1;;;;;10590:9:0;;::::1;::::0;:22:::1;::::0;8258:18:23;;10590:68:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;10668:12;10683:30;10704:8;10683:16;:14;:16::i;:::-;:20:::0;::::1;:30::i;:::-;10723:85;::::0;-1:-1:-1;;;10723:85:0;;10790:10:::1;10723:85;::::0;::::1;2801:51:23::0;2868:18;;;2861:34;;;10668:45:0;;-1:-1:-1;10729:42:0::1;::::0;10723:58:::1;::::0;2774:18:23;;10723:85:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;10833:11;10826:4;:18;10818:46;;;::::0;-1:-1:-1;;;10818:46:0;;11051:2:23;10818:46:0::1;::::0;::::1;11033:21:23::0;11090:2;11070:18;;;11063:30;-1:-1:-1;;;11109:18:23;;;11102:45;11164:18;;10818:46:0::1;10849:339:23::0;10818:46:0::1;10881:4:::0;10230:662;-1:-1:-1;;;10230:662:0:o;1668:101:6:-;1082:7;1108:6;-1:-1:-1;;;;;1108:6:6;719:10:12;1248:23:6;1240:68;;;;-1:-1:-1;;;1240:68:6;;;;;;;:::i;:::-;1732:30:::1;1759:1;1732:18;:30::i;:::-;1668:101::o:0;11348:150:0:-;1082:7:6;1108:6;-1:-1:-1;;;;;1108:6:6;719:10:12;1248:23:6;1240:68;;;;-1:-1:-1;;;1240:68:6;;;;;;;:::i;:::-;11396:5:0::1;:20:::0;;-1:-1:-1;;;;11396:20:0::1;-1:-1:-1::0;;;11396:20:0::1;::::0;;11426:21;:28;;-1:-1:-1;;11426:28:0;;::::1;-1:-1:-1::0;11426:28:0;;::::1;::::0;;;11464:20;:27;;;;::::1;::::0;;::::1;::::0;;11348:150::o;6781:274::-;6835:7;;6869:34;6893:9;6897:5;6893:1;:9;:::i;:::-;6869:4;;;;;;;;;-1:-1:-1;;;;;6869:4:0;-1:-1:-1;;;;;6869:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:34::-;6854:49;;6913:12;6928:29;6951:5;6928:4;;;;;;;;;-1:-1:-1;;;;;6928:4:0;-1:-1:-1;;;;;6928:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:29;6913:44;-1:-1:-1;6967:10:0;6980:11;6913:44;6980:4;:11;:::i;:::-;6967:24;-1:-1:-1;7001:11:0;7015:13;6967:24;7022:5;7015:6;:13::i;:::-;7001:27;6781:274;-1:-1:-1;;;;;;6781:274:0:o;7230:335::-;7282:7;;7321:34;7345:9;7349:5;7345:1;:9;:::i;7321:34::-;7301:54;;7365:16;7384:29;7407:5;7384:4;;;;;;;;;-1:-1:-1;;;;;7384:4:0;-1:-1:-1;;;;;7384:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:29;7365:48;-1:-1:-1;7423:10:0;7436:20;7365:48;7436:9;:20;:::i;:::-;7423:33;-1:-1:-1;7466:10:0;7479:14;7423:33;7479:9;:14;:::i;:::-;7466:27;-1:-1:-1;7503:15:0;7521:13;7526:8;7466:27;7521:13;:::i;:::-;7503:31;7230:335;-1:-1:-1;;;;;;;7230:335:0:o;2125:1298::-;-1:-1:-1;2302:11:0;:26;;2338:9;:22;;;2370:4;:34;;-1:-1:-1;;;;;2302:26:0;;;-1:-1:-1;;;;;;2370:34:0;;;;;;;;2414:13;:42;;;;;;;;;;;;;2466:7;:29;;;;;;;;;;-1:-1:-1;;;;;;2505:17:0;;;;;;;;;2565:9;;2584:4;:56;;2597:42;2584:56;;;;;;-1:-1:-1;2650:61:0;;2668:42;2650:61;;;;;;2721:109;;-1:-1:-1;;;2721:109:0;;-1:-1:-1;2721:109:0;;2801:51:23;;;;-1:-1:-1;;2868:18:23;;;2861:34;2565:9:0;;2668:42;2721:17;;2774:18:23;;2721:109:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;2919:13:0;;2840:183;;-1:-1:-1;;;2840:183:0;;-1:-1:-1;;;;;2919:13:0;;;2840:183;;;2801:51:23;-1:-1:-1;;2868:18:23;;;2861:34;2846:42:0;;2840:57;;2774:18:23;;2840:183:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3033:161:0;;-1:-1:-1;;;3033:161:0;;3114:42;3033:161;;;12118:34:23;3179:4:0;12168:18:23;;;12161:43;3039:42:0;;3033:59;;12053:18:23;;3033:161:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3204:212:0;;-1:-1:-1;;;3204:212:0;;3283:42;3204:212;;;2801:51:23;-1:-1:-1;;2868:18:23;;;2861:34;3210:42:0;;3204:57;;2774:18:23;;3204:212:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;2125:1298;;;;;:::o;6425:240::-;6485:20;;6462:7;;6485:20;;:28;;:12;:28;6481:178;;;-1:-1:-1;6536:5:0;;6425:240::o;6481:178::-;6607:4;;:18;;;-1:-1:-1;;;6607:18:0;;;;6572:10;;-1:-1:-1;;;;;6607:4:0;;:16;;:18;;;;;;;;;;;;;;:4;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6585:4;;;;;;;;;-1:-1:-1;;;;;6585:4:0;-1:-1:-1;;;;;6585:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:40;;;;:::i;8968:255::-;9052:13;;:48;;-1:-1:-1;;;9052:48:0;;9094:4;9052:48;;;753:51:23;9018:4:0;;;;-1:-1:-1;;;;;9052:13:0;;;;:33;;726:18:23;;9052:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:59;;-1:-1:-1;9052:59:0;9149:14;;;:45;;-1:-1:-1;9189:5:0;;9149:45;;;-1:-1:-1;9174:4:0;;9149:45;-1:-1:-1;9211:5:0;8968:255;-1:-1:-1;;;8968:255:0:o;1918:198:6:-;1082:7;1108:6;-1:-1:-1;;;;;1108:6:6;719:10:12;1248:23:6;1240:68;;;;-1:-1:-1;;;1240:68:6;;;;;;;:::i;:::-;-1:-1:-1;;;;;2006:22:6;::::1;1998:73;;;::::0;-1:-1:-1;;;1998:73:6;;12417:2:23;1998:73:6::1;::::0;::::1;12399:21:23::0;12456:2;12436:18;;;12429:30;12495:34;12475:18;;;12468:62;-1:-1:-1;;;12546:18:23;;;12539:36;12592:19;;1998:73:6::1;12215:402:23::0;1998:73:6::1;2081:28;2100:8;2081:18;:28::i;:::-;1918:198:::0;:::o;3835:96:14:-;3893:7;3919:5;3923:1;3919;:5;:::i;3107:96::-;3165:7;3191:5;3195:1;3191;:5;:::i;2740:96::-;2798:7;2824:5;2828:1;2824;:5;:::i;3450:96::-;3508:7;3534:5;3538:1;3534;:5;:::i;2270:187:6:-;2343:16;2362:6;;-1:-1:-1;;;;;2378:17:6;;;-1:-1:-1;;;;;;2378:17:6;;;;;;2410:40;;2362:6;;;;;;;2410:40;;2343:16;2410:40;2333:124;2270:187;:::o;196:131:23:-;-1:-1:-1;;;;;271:31:23;;261:42;;251:70;;317:1;314;307:12;332:247;391:6;444:2;432:9;423:7;419:23;415:32;412:52;;;460:1;457;450:12;412:52;499:9;486:23;518:31;543:5;518:31;:::i;1007:180::-;1066:6;1119:2;1107:9;1098:7;1094:23;1090:32;1087:52;;;1135:1;1132;1125:12;1087:52;-1:-1:-1;1158:23:23;;1007:180;-1:-1:-1;1007:180:23:o;1192:248::-;1260:6;1268;1321:2;1309:9;1300:7;1296:23;1292:32;1289:52;;;1337:1;1334;1327:12;1289:52;-1:-1:-1;;1360:23:23;;;1430:2;1415:18;;;1402:32;;-1:-1:-1;1192:248:23:o;1653:754::-;1762:6;1770;1778;1786;1794;1847:3;1835:9;1826:7;1822:23;1818:33;1815:53;;;1864:1;1861;1854:12;1815:53;1903:9;1890:23;1922:31;1947:5;1922:31;:::i;:::-;1972:5;-1:-1:-1;2024:2:23;2009:18;;1996:32;;-1:-1:-1;2080:2:23;2065:18;;2052:32;2093:33;2052:32;2093:33;:::i;:::-;2145:7;-1:-1:-1;2204:2:23;2189:18;;2176:32;2217:33;2176:32;2217:33;:::i;:::-;2269:7;-1:-1:-1;2328:3:23;2313:19;;2300:33;2342;2300;2342;:::i;:::-;2394:7;2384:17;;;1653:754;;;;;;;;:::o;2412:184::-;2482:6;2535:2;2523:9;2514:7;2510:23;2506:32;2503:52;;;2551:1;2548;2541:12;2503:52;-1:-1:-1;2574:16:23;;2412:184;-1:-1:-1;2412:184:23:o;2906:277::-;2973:6;3026:2;3014:9;3005:7;3001:23;2997:32;2994:52;;;3042:1;3039;3032:12;2994:52;3074:9;3068:16;3127:5;3120:13;3113:21;3106:5;3103:32;3093:60;;3149:1;3146;3139:12;3547:127;3608:10;3603:3;3599:20;3596:1;3589:31;3639:4;3636:1;3629:15;3663:4;3660:1;3653:15;3679:657;3774:6;3827:2;3815:9;3806:7;3802:23;3798:32;3795:52;;;3843:1;3840;3833:12;3795:52;3876:2;3870:9;3918:2;3910:6;3906:15;3987:6;3975:10;3972:22;3951:18;3939:10;3936:34;3933:62;3930:185;;;4037:10;4032:3;4028:20;4025:1;4018:31;4072:4;4069:1;4062:15;4100:4;4097:1;4090:15;3930:185;4135:10;4131:2;4124:22;;4176:9;4170:16;4162:6;4155:32;4241:2;4230:9;4226:18;4220:25;4215:2;4207:6;4203:15;4196:50;4300:2;4289:9;4285:18;4279:25;4274:2;4266:6;4262:15;4255:50;4324:6;4314:16;;;3679:657;;;;:::o;4341:577::-;4573:25;;;4560:3;4545:19;;4628:1;4617:13;;4607:144;;4673:10;4668:3;4664:20;4661:1;4654:31;4708:4;4705:1;4698:15;4736:4;4733:1;4726:15;4607:144;4782:2;4767:18;;4760:34;;;;4837:14;;4830:22;4825:2;4810:18;;4803:50;4896:14;4889:22;4884:2;4869:18;;;4862:50;4341:577;;-1:-1:-1;4341:577:23:o;5975:127::-;6036:10;6031:3;6027:20;6024:1;6017:31;6067:4;6064:1;6057:15;6091:4;6088:1;6081:15;6107:128;6147:3;6178:1;6174:6;6171:1;6168:13;6165:39;;;6184:18;;:::i;:::-;-1:-1:-1;6220:9:23;;6107:128::o;11193:356::-;11395:2;11377:21;;;11414:18;;;11407:30;11473:34;11468:2;11453:18;;11446:62;11540:2;11525:18;;11193:356::o;11554:125::-;11594:4;11622:1;11619;11616:8;11613:34;;;11627:18;;:::i;:::-;-1:-1:-1;11664:9:23;;11554:125::o;11684:217::-;11724:1;11750;11740:132;;11794:10;11789:3;11785:20;11782:1;11775:31;11829:4;11826:1;11819:15;11857:4;11854:1;11847:15;11740:132;-1:-1:-1;11886:9:23;;11684:217::o;12622:168::-;12662:7;12728:1;12724;12720:6;12716:14;12713:1;12710:21;12705:1;12698:9;12691:17;12687:45;12684:71;;;12735:18;;:::i;:::-;-1:-1:-1;12775:9:23;;12622:168::o",
+        "linkReferences": {}
+    },
+    "ast": {
+        "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/contracts/LongFarmer.sol",
+        "exportedSymbols": {
+            "Address": [5037],
+            "ERC20": [6673],
+            "ERC4626": [6285],
+            "ILeveragedPool": [1630],
+            "IPoolCommitter": [1935],
+            "Initializable": [4053],
+            "L2Encoder": [2019],
+            "LongFarmer": [1134],
+            "Ownable": [3911],
+            "SafeMath": [5764],
+            "SafeTransferLib": [6885],
+            "SkewVault": [1326]
+        },
+        "id": 1135,
+        "license": "UNLICENSED",
+        "nodeType": "SourceUnit",
+        "nodes": [
+            {
+                "id": 1,
+                "literals": ["solidity", "^", "0.8", ".0"],
+                "nodeType": "PragmaDirective",
+                "src": "39:23:0"
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/contracts/interfaces/tracer/ILeveragedPool.sol",
+                "file": "./interfaces/tracer/ILeveragedPool.sol",
+                "id": 3,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1135,
+                "sourceUnit": 1631,
+                "src": "63:70:0",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 2,
+                            "name": "ILeveragedPool",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "71:14:0",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/contracts/utils/L2Encoder.sol",
+                "file": "./utils/L2Encoder.sol",
+                "id": 5,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1135,
+                "sourceUnit": 2020,
+                "src": "134:48:0",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 4,
+                            "name": "L2Encoder",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "142:9:0",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/contracts/interfaces/tracer/IPoolCommitter.sol",
+                "file": "./interfaces/tracer/IPoolCommitter.sol",
+                "id": 7,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1135,
+                "sourceUnit": 1936,
+                "src": "183:70:0",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 6,
+                            "name": "IPoolCommitter",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "191:14:0",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/solmate/src/tokens/ERC20.sol",
+                "file": "../lib/solmate/src/tokens/ERC20.sol",
+                "id": 9,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1135,
+                "sourceUnit": 6674,
+                "src": "254:58:0",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 8,
+                            "name": "ERC20",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "262:5:0",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol",
+                "file": "../lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol",
+                "id": 11,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1135,
+                "sourceUnit": 5765,
+                "src": "313:89:0",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 10,
+                            "name": "SafeMath",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "321:8:0",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/contracts/SkewVault.sol",
+                "file": "./SkewVault.sol",
+                "id": 12,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1135,
+                "sourceUnit": 1327,
+                "src": "403:25:0",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/openzeppelin-contracts/contracts/access/Ownable.sol",
+                "file": "../lib/openzeppelin-contracts/contracts/access/Ownable.sol",
+                "id": 14,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1135,
+                "sourceUnit": 3912,
+                "src": "429:83:0",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 13,
+                            "name": "Ownable",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "437:7:0",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/openzeppelin-contracts/contracts/proxy/utils/Initializable.sol",
+                "file": "../lib/openzeppelin-contracts/contracts/proxy/utils/Initializable.sol",
+                "id": 15,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1135,
+                "sourceUnit": 4054,
+                "src": "513:79:0",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "abstract": false,
+                "baseContracts": [
+                    {
+                        "baseName": {
+                            "id": 17,
+                            "name": "Ownable",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 3911,
+                            "src": "1101:7:0"
+                        },
+                        "id": 18,
+                        "nodeType": "InheritanceSpecifier",
+                        "src": "1101:7:0"
+                    }
+                ],
+                "canonicalName": "LongFarmer",
+                "contractDependencies": [],
+                "contractKind": "contract",
+                "documentation": {
+                    "id": 16,
+                    "nodeType": "StructuredDocumentation",
+                    "src": "594:483:0",
+                    "text": " @notice A vault for farming long sided skew against tracer perpetual pools\n @dev if skew exists and the vault is active, tradingStats gets updated to reflect wants, enable swaps\n @dev if skew ceases to exist, tradingStats gets updated to reflect unwinding and block swaps\n @dev Aquiring and disposing must be called mannually for now, and will require role permissions before prod\n @dev EC4626 compatible vault must be deployed prior to initialize of this contract"
+                },
+                "fullyImplemented": true,
+                "id": 1134,
+                "linearizedBaseContracts": [1134, 3911, 5059],
+                "name": "LongFarmer",
+                "nameLocation": "1087:10:0",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "id": 21,
+                        "libraryName": {
+                            "id": 19,
+                            "name": "SafeMath",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 5764,
+                            "src": "1121:8:0"
+                        },
+                        "nodeType": "UsingForDirective",
+                        "src": "1115:27:0",
+                        "typeName": {
+                            "id": 20,
+                            "name": "uint256",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "1134:7:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_uint256",
+                                "typeString": "uint256"
+                            }
+                        }
+                    },
+                    {
+                        "canonicalName": "LongFarmer.State",
+                        "id": 24,
+                        "members": [
+                            {
+                                "id": 22,
+                                "name": "Inactive",
+                                "nameLocation": "1203:8:0",
+                                "nodeType": "EnumValue",
+                                "src": "1203:8:0"
+                            },
+                            {
+                                "id": 23,
+                                "name": "Active",
+                                "nameLocation": "1252:6:0",
+                                "nodeType": "EnumValue",
+                                "src": "1252:6:0"
+                            }
+                        ],
+                        "name": "State",
+                        "nameLocation": "1152:5:0",
+                        "nodeType": "EnumDefinition",
+                        "src": "1147:117:0"
+                    },
+                    {
+                        "canonicalName": "LongFarmer.TradingStats",
+                        "id": 45,
+                        "members": [
+                            {
+                                "constant": false,
+                                "id": 26,
+                                "mutability": "mutable",
+                                "name": "startTime",
+                                "nameLocation": "1393:9:0",
+                                "nodeType": "VariableDeclaration",
+                                "scope": 45,
+                                "src": "1385:17:0",
+                                "stateVariable": false,
+                                "storageLocation": "default",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_uint256",
+                                    "typeString": "uint256"
+                                },
+                                "typeName": {
+                                    "id": 25,
+                                    "name": "uint256",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "1385:7:0",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    }
+                                },
+                                "visibility": "internal"
+                            },
+                            {
+                                "constant": false,
+                                "id": 28,
+                                "mutability": "mutable",
+                                "name": "startSkew",
+                                "nameLocation": "1420:9:0",
+                                "nodeType": "VariableDeclaration",
+                                "scope": 45,
+                                "src": "1412:17:0",
+                                "stateVariable": false,
+                                "storageLocation": "default",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_uint256",
+                                    "typeString": "uint256"
+                                },
+                                "typeName": {
+                                    "id": 27,
+                                    "name": "uint256",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "1412:7:0",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    }
+                                },
+                                "visibility": "internal"
+                            },
+                            {
+                                "constant": false,
+                                "id": 30,
+                                "mutability": "mutable",
+                                "name": "previousPrice",
+                                "nameLocation": "1447:13:0",
+                                "nodeType": "VariableDeclaration",
+                                "scope": 45,
+                                "src": "1439:21:0",
+                                "stateVariable": false,
+                                "storageLocation": "default",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_uint256",
+                                    "typeString": "uint256"
+                                },
+                                "typeName": {
+                                    "id": 29,
+                                    "name": "uint256",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "1439:7:0",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    }
+                                },
+                                "visibility": "internal"
+                            },
+                            {
+                                "constant": false,
+                                "id": 32,
+                                "mutability": "mutable",
+                                "name": "targetAmt",
+                                "nameLocation": "1478:9:0",
+                                "nodeType": "VariableDeclaration",
+                                "scope": 45,
+                                "src": "1470:17:0",
+                                "stateVariable": false,
+                                "storageLocation": "default",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_uint256",
+                                    "typeString": "uint256"
+                                },
+                                "typeName": {
+                                    "id": 31,
+                                    "name": "uint256",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "1470:7:0",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    }
+                                },
+                                "visibility": "internal"
+                            },
+                            {
+                                "constant": false,
+                                "id": 34,
+                                "mutability": "mutable",
+                                "name": "swapping",
+                                "nameLocation": "1502:8:0",
+                                "nodeType": "VariableDeclaration",
+                                "scope": 45,
+                                "src": "1497:13:0",
+                                "stateVariable": false,
+                                "storageLocation": "default",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_bool",
+                                    "typeString": "bool"
+                                },
+                                "typeName": {
+                                    "id": 33,
+                                    "name": "bool",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "1497:4:0",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    }
+                                },
+                                "visibility": "internal"
+                            },
+                            {
+                                "constant": false,
+                                "id": 36,
+                                "mutability": "mutable",
+                                "name": "unWinding",
+                                "nameLocation": "1525:9:0",
+                                "nodeType": "VariableDeclaration",
+                                "scope": 45,
+                                "src": "1520:14:0",
+                                "stateVariable": false,
+                                "storageLocation": "default",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_bool",
+                                    "typeString": "bool"
+                                },
+                                "typeName": {
+                                    "id": 35,
+                                    "name": "bool",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "1520:4:0",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    }
+                                },
+                                "visibility": "internal"
+                            },
+                            {
+                                "constant": false,
+                                "id": 38,
+                                "mutability": "mutable",
+                                "name": "stopping",
+                                "nameLocation": "1549:8:0",
+                                "nodeType": "VariableDeclaration",
+                                "scope": 45,
+                                "src": "1544:13:0",
+                                "stateVariable": false,
+                                "storageLocation": "default",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_bool",
+                                    "typeString": "bool"
+                                },
+                                "typeName": {
+                                    "id": 37,
+                                    "name": "bool",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "1544:4:0",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    }
+                                },
+                                "visibility": "internal"
+                            },
+                            {
+                                "constant": false,
+                                "id": 40,
+                                "mutability": "mutable",
+                                "name": "amtLong",
+                                "nameLocation": "1575:7:0",
+                                "nodeType": "VariableDeclaration",
+                                "scope": 45,
+                                "src": "1567:15:0",
+                                "stateVariable": false,
+                                "storageLocation": "default",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_uint256",
+                                    "typeString": "uint256"
+                                },
+                                "typeName": {
+                                    "id": 39,
+                                    "name": "uint256",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "1567:7:0",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    }
+                                },
+                                "visibility": "internal"
+                            },
+                            {
+                                "constant": false,
+                                "id": 42,
+                                "mutability": "mutable",
+                                "name": "want",
+                                "nameLocation": "1600:4:0",
+                                "nodeType": "VariableDeclaration",
+                                "scope": 45,
+                                "src": "1592:12:0",
+                                "stateVariable": false,
+                                "storageLocation": "default",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_uint256",
+                                    "typeString": "uint256"
+                                },
+                                "typeName": {
+                                    "id": 41,
+                                    "name": "uint256",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "1592:7:0",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    }
+                                },
+                                "visibility": "internal"
+                            },
+                            {
+                                "constant": false,
+                                "id": 44,
+                                "mutability": "mutable",
+                                "name": "testing",
+                                "nameLocation": "1619:7:0",
+                                "nodeType": "VariableDeclaration",
+                                "scope": 45,
+                                "src": "1614:12:0",
+                                "stateVariable": false,
+                                "storageLocation": "default",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_bool",
+                                    "typeString": "bool"
+                                },
+                                "typeName": {
+                                    "id": 43,
+                                    "name": "bool",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "1614:4:0",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    }
+                                },
+                                "visibility": "internal"
+                            }
+                        ],
+                        "name": "TradingStats",
+                        "nameLocation": "1362:12:0",
+                        "nodeType": "StructDefinition",
+                        "scope": 1134,
+                        "src": "1355:278:0",
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": false,
+                        "id": 48,
+                        "mutability": "mutable",
+                        "name": "state",
+                        "nameLocation": "1644:5:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1638:11:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_enum$_State_$24",
+                            "typeString": "enum LongFarmer.State"
+                        },
+                        "typeName": {
+                            "id": 47,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 46,
+                                "name": "State",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 24,
+                                "src": "1638:5:0"
+                            },
+                            "referencedDeclaration": 24,
+                            "src": "1638:5:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_enum$_State_$24",
+                                "typeString": "enum LongFarmer.State"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 51,
+                        "mutability": "mutable",
+                        "name": "tradingStats",
+                        "nameLocation": "1668:12:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1655:25:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                            "typeString": "struct LongFarmer.TradingStats"
+                        },
+                        "typeName": {
+                            "id": 50,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 49,
+                                "name": "TradingStats",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 45,
+                                "src": "1655:12:0"
+                            },
+                            "referencedDeclaration": 45,
+                            "src": "1655:12:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_struct$_TradingStats_$45_storage_ptr",
+                                "typeString": "struct LongFarmer.TradingStats"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 54,
+                        "mutability": "mutable",
+                        "name": "USDC",
+                        "nameLocation": "1721:4:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1715:10:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                            "typeString": "contract ERC20"
+                        },
+                        "typeName": {
+                            "id": 53,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 52,
+                                "name": "ERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6673,
+                                "src": "1715:5:0"
+                            },
+                            "referencedDeclaration": 6673,
+                            "src": "1715:5:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                "typeString": "contract ERC20"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 57,
+                        "mutability": "mutable",
+                        "name": "longToken",
+                        "nameLocation": "1737:9:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1731:15:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                            "typeString": "contract ERC20"
+                        },
+                        "typeName": {
+                            "id": 56,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 55,
+                                "name": "ERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6673,
+                                "src": "1731:5:0"
+                            },
+                            "referencedDeclaration": 6673,
+                            "src": "1731:5:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                "typeString": "contract ERC20"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 60,
+                        "mutability": "mutable",
+                        "name": "poolCommitter",
+                        "nameLocation": "1767:13:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1752:28:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                            "typeString": "contract IPoolCommitter"
+                        },
+                        "typeName": {
+                            "id": 59,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 58,
+                                "name": "IPoolCommitter",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 1935,
+                                "src": "1752:14:0"
+                            },
+                            "referencedDeclaration": 1935,
+                            "src": "1752:14:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                "typeString": "contract IPoolCommitter"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 63,
+                        "mutability": "mutable",
+                        "name": "vault",
+                        "nameLocation": "1792:5:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1786:11:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                            "typeString": "contract ERC20"
+                        },
+                        "typeName": {
+                            "id": 62,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 61,
+                                "name": "ERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6673,
+                                "src": "1786:5:0"
+                            },
+                            "referencedDeclaration": 6673,
+                            "src": "1786:5:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                "typeString": "contract ERC20"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 66,
+                        "mutability": "mutable",
+                        "name": "skewVault",
+                        "nameLocation": "1813:9:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1803:19:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                            "typeString": "contract SkewVault"
+                        },
+                        "typeName": {
+                            "id": 65,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 64,
+                                "name": "SkewVault",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 1326,
+                                "src": "1803:9:0"
+                            },
+                            "referencedDeclaration": 1326,
+                            "src": "1803:9:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                "typeString": "contract SkewVault"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 68,
+                        "mutability": "mutable",
+                        "name": "poolAddress",
+                        "nameLocation": "1836:11:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1828:19:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_address",
+                            "typeString": "address"
+                        },
+                        "typeName": {
+                            "id": 67,
+                            "name": "address",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "1828:7:0",
+                            "stateMutability": "nonpayable",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_address",
+                                "typeString": "address"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "functionSelector": "a4ea5f1d",
+                        "id": 70,
+                        "mutability": "mutable",
+                        "name": "tradeLive",
+                        "nameLocation": "1865:9:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1853:21:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bool",
+                            "typeString": "bool"
+                        },
+                        "typeName": {
+                            "id": 69,
+                            "name": "bool",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "1853:4:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bool",
+                                "typeString": "bool"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": false,
+                        "functionSelector": "42cde4e8",
+                        "id": 72,
+                        "mutability": "mutable",
+                        "name": "threshold",
+                        "nameLocation": "1895:9:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1880:24:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                        },
+                        "typeName": {
+                            "id": 71,
+                            "name": "uint256",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "1880:7:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_uint256",
+                                "typeString": "uint256"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": false,
+                        "id": 74,
+                        "mutability": "mutable",
+                        "name": "window",
+                        "nameLocation": "1918:6:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1910:14:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                        },
+                        "typeName": {
+                            "id": 73,
+                            "name": "uint256",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "1910:7:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_uint256",
+                                "typeString": "uint256"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "functionSelector": "1cc4a40b",
+                        "id": 76,
+                        "mutability": "mutable",
+                        "name": "depUSDC",
+                        "nameLocation": "1945:7:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1930:22:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                        },
+                        "typeName": {
+                            "id": 75,
+                            "name": "uint256",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "1930:7:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_uint256",
+                                "typeString": "uint256"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": false,
+                        "functionSelector": "16f0115b",
+                        "id": 79,
+                        "mutability": "mutable",
+                        "name": "pool",
+                        "nameLocation": "1997:4:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "1975:26:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                            "typeString": "contract ILeveragedPool"
+                        },
+                        "typeName": {
+                            "id": 78,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 77,
+                                "name": "ILeveragedPool",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 1630,
+                                "src": "1975:14:0"
+                            },
+                            "referencedDeclaration": 1630,
+                            "src": "1975:14:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                                "typeString": "contract ILeveragedPool"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": false,
+                        "id": 82,
+                        "mutability": "mutable",
+                        "name": "encoder",
+                        "nameLocation": "2017:7:0",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1134,
+                        "src": "2007:17:0",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_L2Encoder_$2019",
+                            "typeString": "contract L2Encoder"
+                        },
+                        "typeName": {
+                            "id": 81,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 80,
+                                "name": "L2Encoder",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 2019,
+                                "src": "2007:9:0"
+                            },
+                            "referencedDeclaration": 2019,
+                            "src": "2007:9:0",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_L2Encoder_$2019",
+                                "typeString": "contract L2Encoder"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "anonymous": false,
+                        "id": 86,
+                        "name": "unwind",
+                        "nameLocation": "2036:6:0",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 85,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 84,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "_amt",
+                                    "nameLocation": "2051:4:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 86,
+                                    "src": "2043:12:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 83,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2043:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2042:14:0"
+                        },
+                        "src": "2030:27:0"
+                    },
+                    {
+                        "anonymous": false,
+                        "id": 90,
+                        "name": "Log",
+                        "nameLocation": "2068:3:0",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 89,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 88,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "_msg",
+                                    "nameLocation": "2079:4:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 90,
+                                    "src": "2072:11:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 87,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2072:6:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2071:13:0"
+                        },
+                        "src": "2062:23:0"
+                    },
+                    {
+                        "anonymous": false,
+                        "id": 94,
+                        "name": "acquired",
+                        "nameLocation": "2096:8:0",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 93,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 92,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "_amt",
+                                    "nameLocation": "2113:4:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 94,
+                                    "src": "2105:12:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 91,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2105:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2104:14:0"
+                        },
+                        "src": "2090:29:0"
+                    },
+                    {
+                        "body": {
+                            "id": 204,
+                            "nodeType": "Block",
+                            "src": "2292:1131:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 110,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 108,
+                                            "name": "poolAddress",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 68,
+                                            "src": "2302:11:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 109,
+                                            "name": "_poolAddress",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 96,
+                                            "src": "2316:12:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "src": "2302:26:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "id": 111,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2302:26:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 114,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 112,
+                                            "name": "threshold",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 72,
+                                            "src": "2338:9:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 113,
+                                            "name": "_threshold",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 98,
+                                            "src": "2350:10:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "2338:22:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 115,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2338:22:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 120,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 116,
+                                            "name": "pool",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 79,
+                                            "src": "2370:4:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                                                "typeString": "contract ILeveragedPool"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 118,
+                                                    "name": "poolAddress",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 68,
+                                                    "src": "2392:11:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 117,
+                                                "name": "ILeveragedPool",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1630,
+                                                "src": "2377:14:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_contract$_ILeveragedPool_$1630_$",
+                                                    "typeString": "type(contract ILeveragedPool)"
+                                                }
+                                            },
+                                            "id": 119,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "2377:27:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                                                "typeString": "contract ILeveragedPool"
+                                            }
+                                        },
+                                        "src": "2370:34:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                                            "typeString": "contract ILeveragedPool"
+                                        }
+                                    },
+                                    "id": 121,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2370:34:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 126,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 122,
+                                            "name": "poolCommitter",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 60,
+                                            "src": "2414:13:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                "typeString": "contract IPoolCommitter"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 124,
+                                                    "name": "_committer",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 100,
+                                                    "src": "2445:10:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 123,
+                                                "name": "IPoolCommitter",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1935,
+                                                "src": "2430:14:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_contract$_IPoolCommitter_$1935_$",
+                                                    "typeString": "type(contract IPoolCommitter)"
+                                                }
+                                            },
+                                            "id": 125,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "2430:26:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                "typeString": "contract IPoolCommitter"
+                                            }
+                                        },
+                                        "src": "2414:42:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                            "typeString": "contract IPoolCommitter"
+                                        }
+                                    },
+                                    "id": 127,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2414:42:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 132,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 128,
+                                            "name": "encoder",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 82,
+                                            "src": "2466:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_L2Encoder_$2019",
+                                                "typeString": "contract L2Encoder"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 130,
+                                                    "name": "_encoder",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 102,
+                                                    "src": "2486:8:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 129,
+                                                "name": "L2Encoder",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 2019,
+                                                "src": "2476:9:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_contract$_L2Encoder_$2019_$",
+                                                    "typeString": "type(contract L2Encoder)"
+                                                }
+                                            },
+                                            "id": 131,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "2476:19:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_L2Encoder_$2019",
+                                                "typeString": "contract L2Encoder"
+                                            }
+                                        },
+                                        "src": "2466:29:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_L2Encoder_$2019",
+                                            "typeString": "contract L2Encoder"
+                                        }
+                                    },
+                                    "id": 133,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2466:29:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 136,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 134,
+                                            "name": "tradeLive",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 70,
+                                            "src": "2505:9:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "hexValue": "66616c7365",
+                                            "id": 135,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "bool",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "2517:5:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            },
+                                            "value": "false"
+                                        },
+                                        "src": "2505:17:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 137,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2505:17:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 140,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 138,
+                                            "name": "_vault",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 105,
+                                            "src": "2532:6:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                "typeString": "contract ERC20"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 139,
+                                            "name": "vault",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 63,
+                                            "src": "2541:5:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                "typeString": "contract ERC20"
+                                            }
+                                        },
+                                        "src": "2532:14:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                                            "typeString": "contract ERC20"
+                                        }
+                                    },
+                                    "id": 141,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2532:14:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 144,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 142,
+                                            "name": "_vault",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 105,
+                                            "src": "2556:6:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                "typeString": "contract ERC20"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 143,
+                                            "name": "skewVault",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 66,
+                                            "src": "2565:9:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                "typeString": "contract SkewVault"
+                                            }
+                                        },
+                                        "src": "2556:18:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                                            "typeString": "contract ERC20"
+                                        }
+                                    },
+                                    "id": 145,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2556:18:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 150,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 146,
+                                            "name": "USDC",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 54,
+                                            "src": "2584:4:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                "typeString": "contract ERC20"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                    "id": 148,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "2597:42:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    },
+                                                    "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 147,
+                                                "name": "ERC20",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6673,
+                                                "src": "2591:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_contract$_ERC20_$6673_$",
+                                                    "typeString": "type(contract ERC20)"
+                                                }
+                                            },
+                                            "id": 149,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "2591:49:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                "typeString": "contract ERC20"
+                                            }
+                                        },
+                                        "src": "2584:56:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                                            "typeString": "contract ERC20"
+                                        }
+                                    },
+                                    "id": 151,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2584:56:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 156,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 152,
+                                            "name": "longToken",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 57,
+                                            "src": "2650:9:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                "typeString": "contract ERC20"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "hexValue": "307834416144633438303837623536396444334536356442653635423064443033363839313736376533",
+                                                    "id": 154,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "2668:42:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    },
+                                                    "value": "0x4AaDc48087b569dD3E65dBe65B0dD036891767e3"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 153,
+                                                "name": "ERC20",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6673,
+                                                "src": "2662:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_contract$_ERC20_$6673_$",
+                                                    "typeString": "type(contract ERC20)"
+                                                }
+                                            },
+                                            "id": 155,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "2662:49:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                "typeString": "contract ERC20"
+                                            }
+                                        },
+                                        "src": "2650:61:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                                            "typeString": "contract ERC20"
+                                        }
+                                    },
+                                    "id": 157,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2650:61:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 163,
+                                                        "name": "poolCommitter",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 60,
+                                                        "src": "2747:13:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                            "typeString": "contract IPoolCommitter"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                            "typeString": "contract IPoolCommitter"
+                                                        }
+                                                    ],
+                                                    "id": 162,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2739:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 161,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2739:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 164,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2739:22:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "307866666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666",
+                                                "id": 165,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2763:66:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_115792089237316195423570985008687907853269984665640564039457584007913129639935_by_1",
+                                                    "typeString": "int_const 1157...(70 digits omitted)...9935"
+                                                },
+                                                "value": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_115792089237316195423570985008687907853269984665640564039457584007913129639935_by_1",
+                                                    "typeString": "int_const 1157...(70 digits omitted)...9935"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 158,
+                                                "name": "longToken",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 57,
+                                                "src": "2721:9:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 160,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6390,
+                                            "src": "2721:17:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 166,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2721:109:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 167,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2721:109:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 174,
+                                                        "name": "poolCommitter",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 60,
+                                                        "src": "2919:13:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                            "typeString": "contract IPoolCommitter"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                            "typeString": "contract IPoolCommitter"
+                                                        }
+                                                    ],
+                                                    "id": 173,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2911:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 172,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2911:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 175,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2911:22:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "307866666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666",
+                                                "id": 176,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2947:66:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_115792089237316195423570985008687907853269984665640564039457584007913129639935_by_1",
+                                                    "typeString": "int_const 1157...(70 digits omitted)...9935"
+                                                },
+                                                "value": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_115792089237316195423570985008687907853269984665640564039457584007913129639935_by_1",
+                                                    "typeString": "int_const 1157...(70 digits omitted)...9935"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                        "id": 169,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "2846:42:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 168,
+                                                    "name": "ERC20",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 6673,
+                                                    "src": "2840:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_contract$_ERC20_$6673_$",
+                                                        "typeString": "type(contract ERC20)"
+                                                    }
+                                                },
+                                                "id": 170,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2840:49:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 171,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6390,
+                                            "src": "2840:57:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 177,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2840:183:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 178,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2840:183:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307843336432303532343739644243303130343830416531363230343737374331343639434566664339",
+                                                        "id": 185,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "3114:42:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0xC3d2052479dBC010480Ae16204777C1469CEffC9"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 184,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "3106:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 183,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "3106:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 186,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3106:51:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 189,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "3179:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 188,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "3171:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 187,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "3171:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 190,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3171:13:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                        "id": 180,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "3039:42:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 179,
+                                                    "name": "ERC20",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 6673,
+                                                    "src": "3033:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_contract$_ERC20_$6673_$",
+                                                        "typeString": "type(contract ERC20)"
+                                                    }
+                                                },
+                                                "id": 181,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3033:49:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 182,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "allowance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6322,
+                                            "src": "3033:59:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_view$_t_address_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (address,address) view external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 191,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3033:161:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 192,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3033:161:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307843336432303532343739644243303130343830416531363230343737374331343639434566664339",
+                                                        "id": 199,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "3283:42:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0xC3d2052479dBC010480Ae16204777C1469CEffC9"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 198,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "3275:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 197,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "3275:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 200,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3275:51:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "307866666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666",
+                                                "id": 201,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3340:66:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_115792089237316195423570985008687907853269984665640564039457584007913129639935_by_1",
+                                                    "typeString": "int_const 1157...(70 digits omitted)...9935"
+                                                },
+                                                "value": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_115792089237316195423570985008687907853269984665640564039457584007913129639935_by_1",
+                                                    "typeString": "int_const 1157...(70 digits omitted)...9935"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                        "id": 194,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "3210:42:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 193,
+                                                    "name": "ERC20",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 6673,
+                                                    "src": "3204:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_contract$_ERC20_$6673_$",
+                                                        "typeString": "type(contract ERC20)"
+                                                    }
+                                                },
+                                                "id": 195,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3204:49:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 196,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6390,
+                                            "src": "3204:57:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 202,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3204:212:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 203,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3204:212:0"
+                                }
+                            ]
+                        },
+                        "functionSelector": "a01ef25f",
+                        "id": 205,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "initialize",
+                        "nameLocation": "2134:10:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 106,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 96,
+                                    "mutability": "mutable",
+                                    "name": "_poolAddress",
+                                    "nameLocation": "2162:12:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 205,
+                                    "src": "2154:20:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 95,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2154:7:0",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 98,
+                                    "mutability": "mutable",
+                                    "name": "_threshold",
+                                    "nameLocation": "2192:10:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 205,
+                                    "src": "2184:18:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 97,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2184:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 100,
+                                    "mutability": "mutable",
+                                    "name": "_committer",
+                                    "nameLocation": "2220:10:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 205,
+                                    "src": "2212:18:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 99,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2212:7:0",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 102,
+                                    "mutability": "mutable",
+                                    "name": "_encoder",
+                                    "nameLocation": "2248:8:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 205,
+                                    "src": "2240:16:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 101,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2240:7:0",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 105,
+                                    "mutability": "mutable",
+                                    "name": "_vault",
+                                    "nameLocation": "2272:6:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 205,
+                                    "src": "2266:12:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_contract$_ERC20_$6673",
+                                        "typeString": "contract ERC20"
+                                    },
+                                    "typeName": {
+                                        "id": 104,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 103,
+                                            "name": "ERC20",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 6673,
+                                            "src": "2266:5:0"
+                                        },
+                                        "referencedDeclaration": 6673,
+                                        "src": "2266:5:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                                            "typeString": "contract ERC20"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2144:140:0"
+                        },
+                        "returnParameters": {
+                            "id": 107,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2292:0:0"
+                        },
+                        "scope": 1134,
+                        "src": "2125:1298:0",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 244,
+                            "nodeType": "Block",
+                            "src": "3605:280:0",
+                            "statements": [
+                                {
+                                    "assignments": [212],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 212,
+                                            "mutability": "mutable",
+                                            "name": "usdcBal",
+                                            "nameLocation": "3623:7:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 244,
+                                            "src": "3615:15:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 211,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "3615:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 222,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 219,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "3701:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 218,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "3693:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 217,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "3693:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 220,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3693:13:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                        "id": 214,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "3639:42:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 213,
+                                                    "name": "ERC20",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 6673,
+                                                    "src": "3633:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_contract$_ERC20_$6673_$",
+                                                        "typeString": "type(contract ERC20)"
+                                                    }
+                                                },
+                                                "id": 215,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3633:49:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 216,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "balanceOf",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6316,
+                                            "src": "3633:59:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (address) view external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 221,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3633:74:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "3615:92:0"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_enum$_State_$24",
+                                            "typeString": "enum LongFarmer.State"
+                                        },
+                                        "id": 226,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 223,
+                                            "name": "state",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 48,
+                                            "src": "3721:5:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_enum$_State_$24",
+                                                "typeString": "enum LongFarmer.State"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "expression": {
+                                                "id": 224,
+                                                "name": "State",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 24,
+                                                "src": "3730:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_enum$_State_$24_$",
+                                                    "typeString": "type(enum LongFarmer.State)"
+                                                }
+                                            },
+                                            "id": 225,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "Active",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 23,
+                                            "src": "3730:12:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_enum$_State_$24",
+                                                "typeString": "enum LongFarmer.State"
+                                            }
+                                        },
+                                        "src": "3721:21:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 241,
+                                    "nodeType": "IfStatement",
+                                    "src": "3717:138:0",
+                                    "trueBody": {
+                                        "id": 240,
+                                        "nodeType": "Block",
+                                        "src": "3744:111:0",
+                                        "statements": [
+                                            {
+                                                "assignments": [228],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 228,
+                                                        "mutability": "mutable",
+                                                        "name": "_adj",
+                                                        "nameLocation": "3766:4:0",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 240,
+                                                        "src": "3758:12:0",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 227,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "3758:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 235,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [],
+                                                            "expression": {
+                                                                "argumentTypes": [],
+                                                                "id": 232,
+                                                                "name": "longTokenPrice",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 996,
+                                                                "src": "3798:14:0",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_internal_view$__$returns$_t_uint256_$",
+                                                                    "typeString": "function () view returns (uint256)"
+                                                                }
+                                                            },
+                                                            "id": 233,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "3798:16:0",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "expression": {
+                                                                "id": 229,
+                                                                "name": "tradingStats",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 51,
+                                                                "src": "3773:12:0",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                    "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                                }
+                                                            },
+                                                            "id": 230,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "amtLong",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 40,
+                                                            "src": "3773:20:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "id": 231,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "mul",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 5658,
+                                                        "src": "3773:24:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                            "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 234,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "3773:42:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "3758:57:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 238,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "id": 236,
+                                                        "name": "usdcBal",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 212,
+                                                        "src": "3829:7:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "+=",
+                                                    "rightHandSide": {
+                                                        "id": 237,
+                                                        "name": "_adj",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 228,
+                                                        "src": "3840:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "3829:15:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 239,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "3829:15:0"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "expression": {
+                                        "id": 242,
+                                        "name": "usdcBal",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 212,
+                                        "src": "3871:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "functionReturnParameters": 210,
+                                    "id": 243,
+                                    "nodeType": "Return",
+                                    "src": "3864:14:0"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 206,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "3429:124:0",
+                            "text": " @notice Returns the value of the vault, in USDC and LongTokens\n @dev Utility function for skewVault"
+                        },
+                        "functionSelector": "3fa4f245",
+                        "id": 245,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "value",
+                        "nameLocation": "3567:5:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 207,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3572:2:0"
+                        },
+                        "returnParameters": {
+                            "id": 210,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 209,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 245,
+                                    "src": "3596:7:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 208,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3596:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "3595:9:0"
+                        },
+                        "scope": 1134,
+                        "src": "3558:327:0",
+                        "stateMutability": "view",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 532,
+                            "nodeType": "Block",
+                            "src": "4225:2111:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 255,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "id": 252,
+                                                    "name": "window",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 74,
+                                                    "src": "4243:6:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<",
+                                                "rightExpression": {
+                                                    "expression": {
+                                                        "id": 253,
+                                                        "name": "block",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -4,
+                                                        "src": "4252:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_magic_block",
+                                                            "typeString": "block"
+                                                        }
+                                                    },
+                                                    "id": 254,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "timestamp",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "4252:15:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "4243:24:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "706f6b652063616e206f6e6c792062652063616c6c656420686f75726c79",
+                                                "id": 256,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "4269:32:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_06d73f61dcb977b31db97580976ef06bbf15c4d29382bf7d5563cf3c673e5636",
+                                                    "typeString": "literal_string \"poke can only be called hourly\""
+                                                },
+                                                "value": "poke can only be called hourly"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_06d73f61dcb977b31db97580976ef06bbf15c4d29382bf7d5563cf3c673e5636",
+                                                    "typeString": "literal_string \"poke can only be called hourly\""
+                                                }
+                                            ],
+                                            "id": 251,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "4235:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 257,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4235:67:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 258,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "4235:67:0"
+                                },
+                                {
+                                    "assignments": [260],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 260,
+                                            "mutability": "mutable",
+                                            "name": "rate",
+                                            "nameLocation": "4320:4:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 532,
+                                            "src": "4312:12:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 259,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "4312:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 267,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [],
+                                                "expression": {
+                                                    "argumentTypes": [],
+                                                    "id": 264,
+                                                    "name": "longTokenPrice",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 996,
+                                                    "src": "4358:14:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_view$__$returns$_t_uint256_$",
+                                                        "typeString": "function () view returns (uint256)"
+                                                    }
+                                                },
+                                                "id": 265,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "4358:16:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "expression": {
+                                                    "id": 261,
+                                                    "name": "tradingStats",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 51,
+                                                    "src": "4327:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                        "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                    }
+                                                },
+                                                "id": 262,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "previousPrice",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 30,
+                                                "src": "4327:26:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "id": 263,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "div",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5673,
+                                            "src": "4327:30:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                            }
+                                        },
+                                        "id": 266,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4327:48:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "4312:63:0"
+                                },
+                                {
+                                    "assignments": [269],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 269,
+                                            "mutability": "mutable",
+                                            "name": "_skew",
+                                            "nameLocation": "4393:5:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 532,
+                                            "src": "4385:13:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 268,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "4385:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 272,
+                                    "initialValue": {
+                                        "arguments": [],
+                                        "expression": {
+                                            "argumentTypes": [],
+                                            "id": 270,
+                                            "name": "skew",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 561,
+                                            "src": "4401:4:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_view$__$returns$_t_uint256_$",
+                                                "typeString": "function () view returns (uint256)"
+                                            }
+                                        },
+                                        "id": 271,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4401:6:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "4385:22:0"
+                                },
+                                {
+                                    "assignments": [274],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 274,
+                                            "mutability": "mutable",
+                                            "name": "_bool",
+                                            "nameLocation": "4422:5:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 532,
+                                            "src": "4417:10:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            },
+                                            "typeName": {
+                                                "id": 273,
+                                                "name": "bool",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "4417:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 276,
+                                    "initialValue": {
+                                        "hexValue": "66616c7365",
+                                        "id": 275,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": true,
+                                        "kind": "bool",
+                                        "lValueRequested": false,
+                                        "nodeType": "Literal",
+                                        "src": "4430:5:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        },
+                                        "value": "false"
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "4417:18:0"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        },
+                                        "id": 284,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 279,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 277,
+                                                "name": "_skew",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 269,
+                                                "src": "4449:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 278,
+                                                "name": "threshold",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 72,
+                                                "src": "4457:9:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "4449:17:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "&&",
+                                        "rightExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_enum$_State_$24",
+                                                "typeString": "enum LongFarmer.State"
+                                            },
+                                            "id": 283,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 280,
+                                                "name": "state",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 48,
+                                                "src": "4470:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_enum$_State_$24",
+                                                    "typeString": "enum LongFarmer.State"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "!=",
+                                            "rightExpression": {
+                                                "expression": {
+                                                    "id": 281,
+                                                    "name": "State",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 24,
+                                                    "src": "4479:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_enum$_State_$24_$",
+                                                        "typeString": "type(enum LongFarmer.State)"
+                                                    }
+                                                },
+                                                "id": 282,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "memberName": "Active",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 23,
+                                                "src": "4479:12:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_enum$_State_$24",
+                                                    "typeString": "enum LongFarmer.State"
+                                                }
+                                            },
+                                            "src": "4470:21:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "src": "4449:42:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 338,
+                                    "nodeType": "IfStatement",
+                                    "src": "4445:436:0",
+                                    "trueBody": {
+                                        "id": 337,
+                                        "nodeType": "Block",
+                                        "src": "4493:388:0",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "id": 288,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "id": 285,
+                                                        "name": "state",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 48,
+                                                        "src": "4507:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_enum$_State_$24",
+                                                            "typeString": "enum LongFarmer.State"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "expression": {
+                                                            "id": 286,
+                                                            "name": "State",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 24,
+                                                            "src": "4515:5:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_enum$_State_$24_$",
+                                                                "typeString": "type(enum LongFarmer.State)"
+                                                            }
+                                                        },
+                                                        "id": 287,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "memberName": "Active",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 23,
+                                                        "src": "4515:12:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_enum$_State_$24",
+                                                            "typeString": "enum LongFarmer.State"
+                                                        }
+                                                    },
+                                                    "src": "4507:20:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_enum$_State_$24",
+                                                        "typeString": "enum LongFarmer.State"
+                                                    }
+                                                },
+                                                "id": 289,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "4507:20:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 294,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 290,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "4541:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 292,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "startSkew",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 28,
+                                                        "src": "4541:22:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "id": 293,
+                                                        "name": "_skew",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 269,
+                                                        "src": "4566:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "4541:30:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 295,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "4541:30:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 301,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 296,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "4585:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 298,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "startTime",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 26,
+                                                        "src": "4585:22:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "expression": {
+                                                            "id": 299,
+                                                            "name": "block",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -4,
+                                                            "src": "4610:5:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_block",
+                                                                "typeString": "block"
+                                                            }
+                                                        },
+                                                        "id": 300,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "timestamp",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "4610:15:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "4585:40:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 302,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "4585:40:0"
+                                            },
+                                            {
+                                                "assignments": [304],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 304,
+                                                        "mutability": "mutable",
+                                                        "name": "_target",
+                                                        "nameLocation": "4647:7:0",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 337,
+                                                        "src": "4639:15:0",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 303,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "4639:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 308,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 306,
+                                                            "name": "rate",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 260,
+                                                            "src": "4664:4:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 305,
+                                                        "name": "target",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 654,
+                                                        "src": "4657:6:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_uint256_$",
+                                                            "typeString": "function (uint256) view returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 307,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "4657:12:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "4639:30:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 313,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 309,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "4683:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 311,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "targetAmt",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 32,
+                                                        "src": "4683:22:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "id": 312,
+                                                        "name": "_target",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 304,
+                                                        "src": "4708:7:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "4683:32:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 314,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "4683:32:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 319,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 315,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "4729:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 317,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "swapping",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 34,
+                                                        "src": "4729:21:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "74727565",
+                                                        "id": 318,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "4753:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "true"
+                                                    },
+                                                    "src": "4729:28:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 320,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "4729:28:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 325,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 321,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "4771:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 323,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "unWinding",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 36,
+                                                        "src": "4771:22:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "66616c7365",
+                                                        "id": 324,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "4796:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "false"
+                                                    },
+                                                    "src": "4771:30:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 326,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "4771:30:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 331,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 327,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "4815:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 329,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "stopping",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 38,
+                                                        "src": "4815:21:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "66616c7365",
+                                                        "id": 330,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "4839:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "false"
+                                                    },
+                                                    "src": "4815:29:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 332,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "4815:29:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 335,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "id": 333,
+                                                        "name": "_bool",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 274,
+                                                        "src": "4858:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "74727565",
+                                                        "id": 334,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "4866:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "true"
+                                                    },
+                                                    "src": "4858:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 336,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "4858:12:0"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        },
+                                        "id": 351,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            },
+                                            "id": 346,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_enum$_State_$24",
+                                                    "typeString": "enum LongFarmer.State"
+                                                },
+                                                "id": 342,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "id": 339,
+                                                    "name": "state",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 48,
+                                                    "src": "4894:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_enum$_State_$24",
+                                                        "typeString": "enum LongFarmer.State"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "expression": {
+                                                        "id": 340,
+                                                        "name": "State",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 24,
+                                                        "src": "4903:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_enum$_State_$24_$",
+                                                            "typeString": "type(enum LongFarmer.State)"
+                                                        }
+                                                    },
+                                                    "id": 341,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "memberName": "Active",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 23,
+                                                    "src": "4903:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_enum$_State_$24",
+                                                        "typeString": "enum LongFarmer.State"
+                                                    }
+                                                },
+                                                "src": "4894:21:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "&&",
+                                            "rightExpression": {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 345,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "id": 343,
+                                                    "name": "_skew",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 269,
+                                                    "src": "4919:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": ">",
+                                                "rightExpression": {
+                                                    "id": 344,
+                                                    "name": "threshold",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 72,
+                                                    "src": "4927:9:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "4919:17:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            "src": "4894:42:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "&&",
+                                        "rightExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 350,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "expression": {
+                                                    "id": 347,
+                                                    "name": "tradingStats",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 51,
+                                                    "src": "4940:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                        "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                    }
+                                                },
+                                                "id": 348,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "amtLong",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 40,
+                                                "src": "4940:20:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "hexValue": "30",
+                                                "id": 349,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "4963:1:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                    "typeString": "int_const 0"
+                                                },
+                                                "value": "0"
+                                            },
+                                            "src": "4940:24:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "src": "4894:70:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 399,
+                                    "nodeType": "IfStatement",
+                                    "src": "4890:429:0",
+                                    "trueBody": {
+                                        "id": 398,
+                                        "nodeType": "Block",
+                                        "src": "4966:353:0",
+                                        "statements": [
+                                            {
+                                                "assignments": [353],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 353,
+                                                        "mutability": "mutable",
+                                                        "name": "_amtLong",
+                                                        "nameLocation": "4988:8:0",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 398,
+                                                        "src": "4980:16:0",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 352,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "4980:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 356,
+                                                "initialValue": {
+                                                    "expression": {
+                                                        "id": 354,
+                                                        "name": "tradingStats",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 51,
+                                                        "src": "4999:12:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                            "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                        }
+                                                    },
+                                                    "id": 355,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "amtLong",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 40,
+                                                    "src": "4999:20:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "4980:39:0"
+                                            },
+                                            {
+                                                "assignments": [358],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 358,
+                                                        "mutability": "mutable",
+                                                        "name": "_target",
+                                                        "nameLocation": "5041:7:0",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 398,
+                                                        "src": "5033:15:0",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 357,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "5033:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 362,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 360,
+                                                            "name": "rate",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 260,
+                                                            "src": "5058:4:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 359,
+                                                        "name": "target",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 654,
+                                                        "src": "5051:6:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_uint256_$",
+                                                            "typeString": "function (uint256) view returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 361,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5051:12:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "5033:30:0"
+                                            },
+                                            {
+                                                "assignments": [364],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 364,
+                                                        "mutability": "mutable",
+                                                        "name": "_want",
+                                                        "nameLocation": "5085:5:0",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 398,
+                                                        "src": "5077:13:0",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 363,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "5077:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 369,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 367,
+                                                            "name": "_amtLong",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 353,
+                                                            "src": "5105:8:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 365,
+                                                            "name": "_target",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 358,
+                                                            "src": "5093:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "id": 366,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "sub",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 5643,
+                                                        "src": "5093:11:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                            "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 368,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5093:21:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "5077:37:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 374,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 370,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "5128:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 372,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "want",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 42,
+                                                        "src": "5128:17:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "id": 373,
+                                                        "name": "_want",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 364,
+                                                        "src": "5148:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "5128:25:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 375,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5128:25:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 380,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 376,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "5167:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 378,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "swapping",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 34,
+                                                        "src": "5167:21:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "74727565",
+                                                        "id": 379,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "5191:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "true"
+                                                    },
+                                                    "src": "5167:28:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 381,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5167:28:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 386,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 382,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "5209:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 384,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "unWinding",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 36,
+                                                        "src": "5209:22:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "66616c7365",
+                                                        "id": 385,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "5234:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "false"
+                                                    },
+                                                    "src": "5209:30:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 387,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5209:30:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 392,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 388,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "5253:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 390,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "stopping",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 38,
+                                                        "src": "5253:21:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "66616c7365",
+                                                        "id": 391,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "5277:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "false"
+                                                    },
+                                                    "src": "5253:29:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 393,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5253:29:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 396,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "id": 394,
+                                                        "name": "_bool",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 274,
+                                                        "src": "5296:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "74727565",
+                                                        "id": 395,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "5304:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "true"
+                                                    },
+                                                    "src": "5296:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 397,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5296:12:0"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 402,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 400,
+                                            "name": "threshold",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 72,
+                                            "src": "5332:9:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 401,
+                                            "name": "_skew",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 269,
+                                            "src": "5344:5:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "5332:17:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 462,
+                                    "nodeType": "IfStatement",
+                                    "src": "5328:495:0",
+                                    "trueBody": {
+                                        "id": 461,
+                                        "nodeType": "Block",
+                                        "src": "5351:472:0",
+                                        "statements": [
+                                            {
+                                                "assignments": [404],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 404,
+                                                        "mutability": "mutable",
+                                                        "name": "balance",
+                                                        "nameLocation": "5373:7:0",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 461,
+                                                        "src": "5365:15:0",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 403,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "5365:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 422,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "arguments": [
+                                                                            {
+                                                                                "id": 417,
+                                                                                "name": "this",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": -28,
+                                                                                "src": "5481:4:0",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                                    "typeString": "contract LongFarmer"
+                                                                                }
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "argumentTypes": [
+                                                                                {
+                                                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                                    "typeString": "contract LongFarmer"
+                                                                                }
+                                                                            ],
+                                                                            "id": 416,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                            "src": "5473:7:0",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_type$_t_address_$",
+                                                                                "typeString": "type(address)"
+                                                                            },
+                                                                            "typeName": {
+                                                                                "id": 415,
+                                                                                "name": "address",
+                                                                                "nodeType": "ElementaryTypeName",
+                                                                                "src": "5473:7:0",
+                                                                                "typeDescriptions": {}
+                                                                            }
+                                                                        },
+                                                                        "id": 418,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "kind": "typeConversion",
+                                                                        "lValueRequested": false,
+                                                                        "names": [],
+                                                                        "nodeType": "FunctionCall",
+                                                                        "src": "5473:13:0",
+                                                                        "tryCall": false,
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "id": 413,
+                                                                        "name": "poolCommitter",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 60,
+                                                                        "src": "5439:13:0",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                                            "typeString": "contract IPoolCommitter"
+                                                                        }
+                                                                    },
+                                                                    "id": 414,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "getAggregateBalance",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 1904,
+                                                                    "src": "5439:33:0",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_struct$_Balance_$1696_memory_ptr_$",
+                                                                        "typeString": "function (address) view external returns (struct IPoolCommitter.Balance memory)"
+                                                                    }
+                                                                },
+                                                                "id": 419,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "5439:48:0",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_Balance_$1696_memory_ptr",
+                                                                    "typeString": "struct IPoolCommitter.Balance memory"
+                                                                }
+                                                            },
+                                                            "id": 420,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "longTokens",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 1691,
+                                                            "src": "5439:59:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 409,
+                                                                            "name": "this",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": -28,
+                                                                            "src": "5411:4:0",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                                "typeString": "contract LongFarmer"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                                "typeString": "contract LongFarmer"
+                                                                            }
+                                                                        ],
+                                                                        "id": 408,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                                        "src": "5403:7:0",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_type$_t_address_$",
+                                                                            "typeString": "type(address)"
+                                                                        },
+                                                                        "typeName": {
+                                                                            "id": 407,
+                                                                            "name": "address",
+                                                                            "nodeType": "ElementaryTypeName",
+                                                                            "src": "5403:7:0",
+                                                                            "typeDescriptions": {}
+                                                                        }
+                                                                    },
+                                                                    "id": 410,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "typeConversion",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "5403:13:0",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "id": 405,
+                                                                    "name": "longToken",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 57,
+                                                                    "src": "5383:9:0",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                                        "typeString": "contract ERC20"
+                                                                    }
+                                                                },
+                                                                "id": 406,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "memberName": "balanceOf",
+                                                                "nodeType": "MemberAccess",
+                                                                "referencedDeclaration": 6316,
+                                                                "src": "5383:19:0",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_uint256_$",
+                                                                    "typeString": "function (address) view external returns (uint256)"
+                                                                }
+                                                            },
+                                                            "id": 411,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "5383:34:0",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "id": 412,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "add",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 5628,
+                                                        "src": "5383:38:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                            "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 421,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5383:129:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "5365:147:0"
+                                            },
+                                            {
+                                                "assignments": [424],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 424,
+                                                        "mutability": "mutable",
+                                                        "name": "args",
+                                                        "nameLocation": "5534:4:0",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 461,
+                                                        "src": "5526:12:0",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 423,
+                                                            "name": "bytes32",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "5526:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 434,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 427,
+                                                            "name": "balance",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 404,
+                                                            "src": "5568:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "expression": {
+                                                                "expression": {
+                                                                    "id": 428,
+                                                                    "name": "IPoolCommitter",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 1935,
+                                                                    "src": "5577:14:0",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_type$_t_contract$_IPoolCommitter_$1935_$",
+                                                                        "typeString": "type(contract IPoolCommitter)"
+                                                                    }
+                                                                },
+                                                                "id": 429,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "memberName": "CommitType",
+                                                                "nodeType": "MemberAccess",
+                                                                "referencedDeclaration": 1640,
+                                                                "src": "5577:25:0",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_enum$_CommitType_$1640_$",
+                                                                    "typeString": "type(enum IPoolCommitter.CommitType)"
+                                                                }
+                                                            },
+                                                            "id": 430,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "memberName": "LongBurn",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 1637,
+                                                            "src": "5577:34:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_enum$_CommitType_$1640",
+                                                                "typeString": "enum IPoolCommitter.CommitType"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "66616c7365",
+                                                            "id": 431,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "bool",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5613:5:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bool",
+                                                                "typeString": "bool"
+                                                            },
+                                                            "value": "false"
+                                                        },
+                                                        {
+                                                            "hexValue": "74727565",
+                                                            "id": 432,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "bool",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5620:4:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bool",
+                                                                "typeString": "bool"
+                                                            },
+                                                            "value": "true"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_enum$_CommitType_$1640",
+                                                                "typeString": "enum IPoolCommitter.CommitType"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bool",
+                                                                "typeString": "bool"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bool",
+                                                                "typeString": "bool"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 425,
+                                                            "name": "encoder",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 82,
+                                                            "src": "5541:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_L2Encoder_$2019",
+                                                                "typeString": "contract L2Encoder"
+                                                            }
+                                                        },
+                                                        "id": 426,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "encodeCommitParams",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 2018,
+                                                        "src": "5541:26:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_pure$_t_uint256_$_t_enum$_CommitType_$1640_$_t_bool_$_t_bool_$returns$_t_bytes32_$",
+                                                            "typeString": "function (uint256,enum IPoolCommitter.CommitType,bool,bool) pure external returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 433,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5541:84:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "5526:99:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 438,
+                                                            "name": "args",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 424,
+                                                            "src": "5660:4:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 435,
+                                                            "name": "poolCommitter",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 60,
+                                                            "src": "5639:13:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                                "typeString": "contract IPoolCommitter"
+                                                            }
+                                                        },
+                                                        "id": 437,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "commit",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 1845,
+                                                        "src": "5639:20:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_payable$_t_bytes32_$returns$__$",
+                                                            "typeString": "function (bytes32) payable external"
+                                                        }
+                                                    },
+                                                    "id": 439,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5639:26:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 440,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5639:26:0"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 442,
+                                                            "name": "balance",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 404,
+                                                            "src": "5691:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 441,
+                                                        "name": "unwind",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 86,
+                                                        "src": "5684:6:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_uint256_$returns$__$",
+                                                            "typeString": "function (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 443,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5684:15:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 444,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5679:20:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 449,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 445,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "5713:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 447,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "unWinding",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 36,
+                                                        "src": "5713:22:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "74727565",
+                                                        "id": 448,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "5738:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "true"
+                                                    },
+                                                    "src": "5713:29:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 450,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5713:29:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 455,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 451,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "5756:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 453,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "swapping",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 34,
+                                                        "src": "5756:21:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "66616c7365",
+                                                        "id": 454,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "5780:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "false"
+                                                    },
+                                                    "src": "5756:29:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 456,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5756:29:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 459,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "id": 457,
+                                                        "name": "_bool",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 274,
+                                                        "src": "5799:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "66616c7365",
+                                                        "id": 458,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "5807:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "false"
+                                                    },
+                                                    "src": "5799:13:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 460,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5799:13:0"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 467,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 464,
+                                                    "name": "rate",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 260,
+                                                    "src": "5845:4:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "id": 463,
+                                                "name": "nextSkew",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 605,
+                                                "src": "5836:8:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_uint256_$",
+                                                    "typeString": "function (uint256) view returns (uint256)"
+                                                }
+                                            },
+                                            "id": 465,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "5836:14:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "<",
+                                        "rightExpression": {
+                                            "id": 466,
+                                            "name": "threshold",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 72,
+                                            "src": "5853:9:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "5836:26:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 489,
+                                    "nodeType": "IfStatement",
+                                    "src": "5832:193:0",
+                                    "trueBody": {
+                                        "id": 488,
+                                        "nodeType": "Block",
+                                        "src": "5864:161:0",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "id": 472,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 468,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "5878:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 470,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "swapping",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 34,
+                                                        "src": "5878:21:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "66616c7365",
+                                                        "id": 471,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "5902:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "false"
+                                                    },
+                                                    "src": "5878:29:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 473,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5878:29:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 478,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "expression": {
+                                                            "id": 474,
+                                                            "name": "tradingStats",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 51,
+                                                            "src": "5921:12:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                                "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                            }
+                                                        },
+                                                        "id": 476,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "memberName": "stopping",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 38,
+                                                        "src": "5921:21:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "74727565",
+                                                        "id": 477,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "5945:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "true"
+                                                    },
+                                                    "src": "5921:28:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 479,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5921:28:0"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "6e6f206d6f726520736b6577",
+                                                            "id": 481,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5972:14:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_75971dab7bcc01a685b439a0cbec47bc54d2a54e034a4fdb4d43982353c4b7f1",
+                                                                "typeString": "literal_string \"no more skew\""
+                                                            },
+                                                            "value": "no more skew"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_75971dab7bcc01a685b439a0cbec47bc54d2a54e034a4fdb4d43982353c4b7f1",
+                                                                "typeString": "literal_string \"no more skew\""
+                                                            }
+                                                        ],
+                                                        "id": 480,
+                                                        "name": "Log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 90,
+                                                        "src": "5968:3:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 482,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5968:19:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 483,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5963:24:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 486,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "id": 484,
+                                                        "name": "_bool",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 274,
+                                                        "src": "6001:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "66616c7365",
+                                                        "id": 485,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "6009:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "false"
+                                                    },
+                                                    "src": "6001:13:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 487,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "6001:13:0"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "eventCall": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "706f6b657920706f6b6579",
+                                                "id": 491,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "6043:13:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_149432685b960ff54518563a484247e5b86b79a96126d790e58d5c7b329b8cf8",
+                                                    "typeString": "literal_string \"pokey pokey\""
+                                                },
+                                                "value": "pokey pokey"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_149432685b960ff54518563a484247e5b86b79a96126d790e58d5c7b329b8cf8",
+                                                    "typeString": "literal_string \"pokey pokey\""
+                                                }
+                                            ],
+                                            "id": 490,
+                                            "name": "Log",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 90,
+                                            "src": "6039:3:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (string memory)"
+                                            }
+                                        },
+                                        "id": 492,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "6039:18:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 493,
+                                    "nodeType": "EmitStatement",
+                                    "src": "6034:23:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 499,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 494,
+                                            "name": "window",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 74,
+                                            "src": "6067:6:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 498,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "expression": {
+                                                    "id": 495,
+                                                    "name": "block",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": -4,
+                                                    "src": "6076:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_magic_block",
+                                                        "typeString": "block"
+                                                    }
+                                                },
+                                                "id": 496,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "timestamp",
+                                                "nodeType": "MemberAccess",
+                                                "src": "6076:15:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "+",
+                                            "rightExpression": {
+                                                "hexValue": "33363030",
+                                                "id": 497,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "6094:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_3600_by_1",
+                                                    "typeString": "int_const 3600"
+                                                },
+                                                "value": "3600"
+                                            },
+                                            "src": "6076:22:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "6067:31:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 500,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "6067:31:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 521,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 501,
+                                                "name": "tradingStats",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 51,
+                                                "src": "6108:12:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                    "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                }
+                                            },
+                                            "id": 503,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "amtLong",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 40,
+                                            "src": "6108:20:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "expression": {
+                                                        "arguments": [
+                                                            {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 516,
+                                                                        "name": "this",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": -28,
+                                                                        "src": "6225:4:0",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                            "typeString": "contract LongFarmer"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                            "typeString": "contract LongFarmer"
+                                                                        }
+                                                                    ],
+                                                                    "id": 515,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                                    "src": "6217:7:0",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                                        "typeString": "type(address)"
+                                                                    },
+                                                                    "typeName": {
+                                                                        "id": 514,
+                                                                        "name": "address",
+                                                                        "nodeType": "ElementaryTypeName",
+                                                                        "src": "6217:7:0",
+                                                                        "typeDescriptions": {}
+                                                                    }
+                                                                },
+                                                                "id": 517,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "typeConversion",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "6217:13:0",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_address",
+                                                                    "typeString": "address"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_address",
+                                                                    "typeString": "address"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "id": 512,
+                                                                "name": "poolCommitter",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 60,
+                                                                "src": "6183:13:0",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                                    "typeString": "contract IPoolCommitter"
+                                                                }
+                                                            },
+                                                            "id": 513,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "getAggregateBalance",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 1904,
+                                                            "src": "6183:33:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_struct$_Balance_$1696_memory_ptr_$",
+                                                                "typeString": "function (address) view external returns (struct IPoolCommitter.Balance memory)"
+                                                            }
+                                                        },
+                                                        "id": 518,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "6183:48:0",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_Balance_$1696_memory_ptr",
+                                                            "typeString": "struct IPoolCommitter.Balance memory"
+                                                        }
+                                                    },
+                                                    "id": 519,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "longTokens",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 1691,
+                                                    "src": "6183:59:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "id": 508,
+                                                                    "name": "this",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": -28,
+                                                                    "src": "6159:4:0",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                        "typeString": "contract LongFarmer"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                        "typeString": "contract LongFarmer"
+                                                                    }
+                                                                ],
+                                                                "id": 507,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "6151:7:0",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_address_$",
+                                                                    "typeString": "type(address)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 506,
+                                                                    "name": "address",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "6151:7:0",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 509,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "6151:13:0",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 504,
+                                                            "name": "longToken",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 57,
+                                                            "src": "6131:9:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                                "typeString": "contract ERC20"
+                                                            }
+                                                        },
+                                                        "id": 505,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "balanceOf",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 6316,
+                                                        "src": "6131:19:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_uint256_$",
+                                                            "typeString": "function (address) view external returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 510,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6131:34:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 511,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "add",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5628,
+                                                "src": "6131:38:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                    "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                                }
+                                            },
+                                            "id": 520,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "6131:121:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "6108:144:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 522,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "6108:144:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 528,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 523,
+                                                "name": "tradingStats",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 51,
+                                                "src": "6262:12:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                    "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                }
+                                            },
+                                            "id": 525,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "previousPrice",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 30,
+                                            "src": "6262:26:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [],
+                                            "expression": {
+                                                "argumentTypes": [],
+                                                "id": 526,
+                                                "name": "longTokenPrice",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 996,
+                                                "src": "6291:14:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_view$__$returns$_t_uint256_$",
+                                                    "typeString": "function () view returns (uint256)"
+                                                }
+                                            },
+                                            "id": 527,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "6291:16:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "6262:45:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 529,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "6262:45:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 530,
+                                        "name": "_bool",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 274,
+                                        "src": "6324:5:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "functionReturnParameters": 250,
+                                    "id": 531,
+                                    "nodeType": "Return",
+                                    "src": "6317:12:0"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 246,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "3891:291:0",
+                            "text": " @notice Pokes the vault to conduct skew checks and update wants\n @dev if skew exists and the vault is active, tradingStats gets updated to reflect wants, enable swaps\n @dev if skew ceases to exist, tradingStats gets updated to reflect unwinding and block swaps"
+                        },
+                        "functionSelector": "18178358",
+                        "id": 533,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "poke",
+                        "nameLocation": "4196:4:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 247,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "4200:2:0"
+                        },
+                        "returnParameters": {
+                            "id": 250,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 249,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 533,
+                                    "src": "4219:4:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 248,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4219:4:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4218:6:0"
+                        },
+                        "scope": 1134,
+                        "src": "4187:2149:0",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 560,
+                            "nodeType": "Block",
+                            "src": "6471:194:0",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        },
+                                        "id": 542,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "expression": {
+                                                "id": 539,
+                                                "name": "tradingStats",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 51,
+                                                "src": "6485:12:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                    "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                }
+                                            },
+                                            "id": 540,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "testing",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 44,
+                                            "src": "6485:20:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "74727565",
+                                            "id": 541,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "bool",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "6509:4:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            },
+                                            "value": "true"
+                                        },
+                                        "src": "6485:28:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "falseBody": {
+                                        "id": 558,
+                                        "nodeType": "Block",
+                                        "src": "6558:101:0",
+                                        "statements": [
+                                            {
+                                                "assignments": [547],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 547,
+                                                        "mutability": "mutable",
+                                                        "name": "_s",
+                                                        "nameLocation": "6580:2:0",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 558,
+                                                        "src": "6572:10:0",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 546,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "6572:7:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 555,
+                                                "initialValue": {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    "id": 554,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "arguments": [],
+                                                        "expression": {
+                                                            "argumentTypes": [],
+                                                            "expression": {
+                                                                "id": 548,
+                                                                "name": "pool",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 79,
+                                                                "src": "6585:4:0",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                                                                    "typeString": "contract ILeveragedPool"
+                                                                }
+                                                            },
+                                                            "id": 549,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "shortBalance",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 1492,
+                                                            "src": "6585:17:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$",
+                                                                "typeString": "function () view external returns (uint256)"
+                                                            }
+                                                        },
+                                                        "id": 550,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "6585:19:0",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "/",
+                                                    "rightExpression": {
+                                                        "arguments": [],
+                                                        "expression": {
+                                                            "argumentTypes": [],
+                                                            "expression": {
+                                                                "id": 551,
+                                                                "name": "pool",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 79,
+                                                                "src": "6607:4:0",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                                                                    "typeString": "contract ILeveragedPool"
+                                                                }
+                                                            },
+                                                            "id": 552,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "longBalance",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 1497,
+                                                            "src": "6607:16:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$",
+                                                                "typeString": "function () view external returns (uint256)"
+                                                            }
+                                                        },
+                                                        "id": 553,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "6607:18:0",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "6585:40:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "6572:53:0"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 556,
+                                                    "name": "_s",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 547,
+                                                    "src": "6646:2:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "functionReturnParameters": 538,
+                                                "id": 557,
+                                                "nodeType": "Return",
+                                                "src": "6639:9:0"
+                                            }
+                                        ]
+                                    },
+                                    "id": 559,
+                                    "nodeType": "IfStatement",
+                                    "src": "6481:178:0",
+                                    "trueBody": {
+                                        "id": 545,
+                                        "nodeType": "Block",
+                                        "src": "6515:37:0",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "hexValue": "3130303030",
+                                                    "id": 543,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "6536:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_10000_by_1",
+                                                        "typeString": "int_const 10000"
+                                                    },
+                                                    "value": "10000"
+                                                },
+                                                "functionReturnParameters": 538,
+                                                "id": 544,
+                                                "nodeType": "Return",
+                                                "src": "6529:12:0"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 534,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "6342:78:0",
+                            "text": " @notice Gets the current pool skew\n @dev returns skew"
+                        },
+                        "functionSelector": "b27979ca",
+                        "id": 561,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "skew",
+                        "nameLocation": "6434:4:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 535,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "6438:2:0"
+                        },
+                        "returnParameters": {
+                            "id": 538,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 537,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 561,
+                                    "src": "6462:7:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 536,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6462:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "6461:9:0"
+                        },
+                        "scope": 1134,
+                        "src": "6425:240:0",
+                        "stateMutability": "view",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 604,
+                            "nodeType": "Block",
+                            "src": "6844:211:0",
+                            "statements": [
+                                {
+                                    "assignments": [570],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 570,
+                                            "mutability": "mutable",
+                                            "name": "sBal",
+                                            "nameLocation": "6862:4:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 604,
+                                            "src": "6854:12:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 569,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "6854:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 579,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 577,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 575,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "6893:1:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "-",
+                                                "rightExpression": {
+                                                    "id": 576,
+                                                    "name": "_rate",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 564,
+                                                    "src": "6897:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "6893:9:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [],
+                                                "expression": {
+                                                    "argumentTypes": [],
+                                                    "expression": {
+                                                        "id": 571,
+                                                        "name": "pool",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 79,
+                                                        "src": "6869:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                                                            "typeString": "contract ILeveragedPool"
+                                                        }
+                                                    },
+                                                    "id": 572,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "shortBalance",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 1492,
+                                                    "src": "6869:17:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$",
+                                                        "typeString": "function () view external returns (uint256)"
+                                                    }
+                                                },
+                                                "id": 573,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "6869:19:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "id": 574,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "mul",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5658,
+                                            "src": "6869:23:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                            }
+                                        },
+                                        "id": 578,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "6869:34:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "6854:49:0"
+                                },
+                                {
+                                    "assignments": [581],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 581,
+                                            "mutability": "mutable",
+                                            "name": "lBal",
+                                            "nameLocation": "6921:4:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 604,
+                                            "src": "6913:12:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 580,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "6913:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 588,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 586,
+                                                "name": "_rate",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 564,
+                                                "src": "6951:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [],
+                                                "expression": {
+                                                    "argumentTypes": [],
+                                                    "expression": {
+                                                        "id": 582,
+                                                        "name": "pool",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 79,
+                                                        "src": "6928:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                                                            "typeString": "contract ILeveragedPool"
+                                                        }
+                                                    },
+                                                    "id": 583,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "longBalance",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 1497,
+                                                    "src": "6928:16:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$",
+                                                        "typeString": "function () view external returns (uint256)"
+                                                    }
+                                                },
+                                                "id": 584,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "6928:18:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "id": 585,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "mul",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5658,
+                                            "src": "6928:22:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                            }
+                                        },
+                                        "id": 587,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "6928:29:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "6913:44:0"
+                                },
+                                {
+                                    "assignments": [590],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 590,
+                                            "mutability": "mutable",
+                                            "name": "_s",
+                                            "nameLocation": "6975:2:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 604,
+                                            "src": "6967:10:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 589,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "6967:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 594,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 593,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 591,
+                                            "name": "sBal",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 570,
+                                            "src": "6980:4:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 592,
+                                            "name": "lBal",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 581,
+                                            "src": "6987:4:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "6980:11:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "6967:24:0"
+                                },
+                                {
+                                    "assignments": [596],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 596,
+                                            "mutability": "mutable",
+                                            "name": "_nS",
+                                            "nameLocation": "7009:3:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 604,
+                                            "src": "7001:11:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 595,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "7001:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 601,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 599,
+                                                "name": "_rate",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 564,
+                                                "src": "7022:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 597,
+                                                "name": "_s",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 590,
+                                                "src": "7015:2:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "id": 598,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "mul",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5658,
+                                            "src": "7015:6:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                            }
+                                        },
+                                        "id": 600,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "7015:13:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "7001:27:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 602,
+                                        "name": "_nS",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 596,
+                                        "src": "7045:3:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "functionReturnParameters": 568,
+                                    "id": 603,
+                                    "nodeType": "Return",
+                                    "src": "7038:10:0"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 562,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "6671:105:0",
+                            "text": " @notice Returns the predicted next skew\n @param _rate the current rate of change"
+                        },
+                        "functionSelector": "905c9321",
+                        "id": 605,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "nextSkew",
+                        "nameLocation": "6790:8:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 565,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 564,
+                                    "mutability": "mutable",
+                                    "name": "_rate",
+                                    "nameLocation": "6807:5:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 605,
+                                    "src": "6799:13:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 563,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6799:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "6798:15:0"
+                        },
+                        "returnParameters": {
+                            "id": 568,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 567,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 605,
+                                    "src": "6835:7:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 566,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6835:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "6834:9:0"
+                        },
+                        "scope": 1134,
+                        "src": "6781:274:0",
+                        "stateMutability": "view",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 653,
+                            "nodeType": "Block",
+                            "src": "7291:274:0",
+                            "statements": [
+                                {
+                                    "assignments": [614],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 614,
+                                            "mutability": "mutable",
+                                            "name": "_shortBal",
+                                            "nameLocation": "7309:9:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 653,
+                                            "src": "7301:17:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 613,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "7301:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 623,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 621,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 619,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "7345:1:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "-",
+                                                "rightExpression": {
+                                                    "id": 620,
+                                                    "name": "_rate",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 608,
+                                                    "src": "7349:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "7345:9:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [],
+                                                "expression": {
+                                                    "argumentTypes": [],
+                                                    "expression": {
+                                                        "id": 615,
+                                                        "name": "pool",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 79,
+                                                        "src": "7321:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                                                            "typeString": "contract ILeveragedPool"
+                                                        }
+                                                    },
+                                                    "id": 616,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "shortBalance",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 1492,
+                                                    "src": "7321:17:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$",
+                                                        "typeString": "function () view external returns (uint256)"
+                                                    }
+                                                },
+                                                "id": 617,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "7321:19:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "id": 618,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "mul",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5658,
+                                            "src": "7321:23:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                            }
+                                        },
+                                        "id": 622,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "7321:34:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "7301:54:0"
+                                },
+                                {
+                                    "assignments": [625],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 625,
+                                            "mutability": "mutable",
+                                            "name": "_LongBal",
+                                            "nameLocation": "7373:8:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 653,
+                                            "src": "7365:16:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 624,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "7365:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 632,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 630,
+                                                "name": "_rate",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 608,
+                                                "src": "7407:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [],
+                                                "expression": {
+                                                    "argumentTypes": [],
+                                                    "expression": {
+                                                        "id": 626,
+                                                        "name": "pool",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 79,
+                                                        "src": "7384:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                                                            "typeString": "contract ILeveragedPool"
+                                                        }
+                                                    },
+                                                    "id": 627,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "longBalance",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 1497,
+                                                    "src": "7384:16:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$",
+                                                        "typeString": "function () view external returns (uint256)"
+                                                    }
+                                                },
+                                                "id": 628,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "7384:18:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "id": 629,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "mul",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5658,
+                                            "src": "7384:22:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                            }
+                                        },
+                                        "id": 631,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "7384:29:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "7365:48:0"
+                                },
+                                {
+                                    "assignments": [634],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 634,
+                                            "mutability": "mutable",
+                                            "name": "_s",
+                                            "nameLocation": "7431:2:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 653,
+                                            "src": "7423:10:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 633,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "7423:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 638,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 637,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 635,
+                                            "name": "_shortBal",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 614,
+                                            "src": "7436:9:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 636,
+                                            "name": "_LongBal",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 625,
+                                            "src": "7448:8:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "7436:20:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "7423:33:0"
+                                },
+                                {
+                                    "assignments": [640],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 640,
+                                            "mutability": "mutable",
+                                            "name": "_t",
+                                            "nameLocation": "7474:2:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 653,
+                                            "src": "7466:10:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 639,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "7466:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 644,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 643,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 641,
+                                            "name": "_shortBal",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 614,
+                                            "src": "7479:9:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 642,
+                                            "name": "_s",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 634,
+                                            "src": "7491:2:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "7479:14:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "7466:27:0"
+                                },
+                                {
+                                    "assignments": [646],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 646,
+                                            "mutability": "mutable",
+                                            "name": "_target",
+                                            "nameLocation": "7511:7:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 653,
+                                            "src": "7503:15:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 645,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "7503:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 650,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 649,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 647,
+                                            "name": "_t",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 640,
+                                            "src": "7521:2:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "-",
+                                        "rightExpression": {
+                                            "id": 648,
+                                            "name": "_LongBal",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 625,
+                                            "src": "7526:8:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "7521:13:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "7503:31:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 651,
+                                        "name": "_target",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 646,
+                                        "src": "7551:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "functionReturnParameters": 612,
+                                    "id": 652,
+                                    "nodeType": "Return",
+                                    "src": "7544:14:0"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 606,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "7061:164:0",
+                            "text": " @notice Gets the target value of wants for the vault to bring skew back to 1\n @param _rate rate of change of long token from previous price"
+                        },
+                        "functionSelector": "9811c7c1",
+                        "id": 654,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "target",
+                        "nameLocation": "7239:6:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 609,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 608,
+                                    "mutability": "mutable",
+                                    "name": "_rate",
+                                    "nameLocation": "7254:5:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 654,
+                                    "src": "7246:13:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 607,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7246:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "7245:15:0"
+                        },
+                        "returnParameters": {
+                            "id": 612,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 611,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 654,
+                                    "src": "7282:7:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 610,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7282:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "7281:9:0"
+                        },
+                        "scope": 1134,
+                        "src": "7230:335:0",
+                        "stateMutability": "view",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 765,
+                            "nodeType": "Block",
+                            "src": "7809:934:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_enum$_State_$24",
+                                                    "typeString": "enum LongFarmer.State"
+                                                },
+                                                "id": 664,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "id": 661,
+                                                    "name": "state",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 48,
+                                                    "src": "7827:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_enum$_State_$24",
+                                                        "typeString": "enum LongFarmer.State"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "expression": {
+                                                        "id": 662,
+                                                        "name": "State",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 24,
+                                                        "src": "7836:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_enum$_State_$24_$",
+                                                            "typeString": "type(enum LongFarmer.State)"
+                                                        }
+                                                    },
+                                                    "id": 663,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "memberName": "Active",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 23,
+                                                    "src": "7836:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_enum$_State_$24",
+                                                        "typeString": "enum LongFarmer.State"
+                                                    }
+                                                },
+                                                "src": "7827:21:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "7661756c74206d7573742062652061637469766520746f2061637175697265",
+                                                "id": 665,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "7850:33:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_51a3366f31224cd8fde050f204a7ac332005ba0cbf6a6648f8187a8d49915c46",
+                                                    "typeString": "literal_string \"vault must be active to acquire\""
+                                                },
+                                                "value": "vault must be active to acquire"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_51a3366f31224cd8fde050f204a7ac332005ba0cbf6a6648f8187a8d49915c46",
+                                                    "typeString": "literal_string \"vault must be active to acquire\""
+                                                }
+                                            ],
+                                            "id": 660,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "7819:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 666,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "7819:65:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 667,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "7819:65:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "id": 672,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 669,
+                                                        "name": "tradingStats",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 51,
+                                                        "src": "7902:12:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                            "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                        }
+                                                    },
+                                                    "id": 670,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "unWinding",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 36,
+                                                    "src": "7902:22:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "hexValue": "66616c7365",
+                                                    "id": 671,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "bool",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "7928:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    },
+                                                    "value": "false"
+                                                },
+                                                "src": "7902:31:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "7661756c74206d757374206265206171756972696e67206e6f7420756e77696e64696e67",
+                                                "id": 673,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "7935:38:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_d6d72e438615e5696bd1e7f8efa2bc331678bf41dfcb8bcbfdd54b7f726e774e",
+                                                    "typeString": "literal_string \"vault must be aquiring not unwinding\""
+                                                },
+                                                "value": "vault must be aquiring not unwinding"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_d6d72e438615e5696bd1e7f8efa2bc331678bf41dfcb8bcbfdd54b7f726e774e",
+                                                    "typeString": "literal_string \"vault must be aquiring not unwinding\""
+                                                }
+                                            ],
+                                            "id": 668,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "7894:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 674,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "7894:80:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 675,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "7894:80:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 680,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 677,
+                                                        "name": "skew",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 561,
+                                                        "src": "7992:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_view$__$returns$_t_uint256_$",
+                                                            "typeString": "function () view returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 678,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7992:6:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": ">",
+                                                "rightExpression": {
+                                                    "id": 679,
+                                                    "name": "threshold",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 72,
+                                                    "src": "8001:9:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "7992:18:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "706f6f6c73206d75737420626520736b6577656420746f2061637175697265",
+                                                "id": 681,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "8012:33:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_ded9b2e60bba7693ba030fa7a8b743439ecf204c5873113f5f77f7082a62dfb2",
+                                                    "typeString": "literal_string \"pools must be skewed to acquire\""
+                                                },
+                                                "value": "pools must be skewed to acquire"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_ded9b2e60bba7693ba030fa7a8b743439ecf204c5873113f5f77f7082a62dfb2",
+                                                    "typeString": "literal_string \"pools must be skewed to acquire\""
+                                                }
+                                            ],
+                                            "id": 676,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "7984:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 682,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "7984:62:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 683,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "7984:62:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "id": 688,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 685,
+                                                        "name": "tradingStats",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 51,
+                                                        "src": "8064:12:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                            "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                        }
+                                                    },
+                                                    "id": 686,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "stopping",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 38,
+                                                    "src": "8064:21:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "!=",
+                                                "rightExpression": {
+                                                    "hexValue": "74727565",
+                                                    "id": 687,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "bool",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "8089:4:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    },
+                                                    "value": "true"
+                                                },
+                                                "src": "8064:29:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "6e65787420736b657720756e646572207468726573686f6c64",
+                                                "id": 689,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "8095:27:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_bfce3553988e17149500ee032e0a7bd1a3a5ca7057ec0b42e704d83d2f58912f",
+                                                    "typeString": "literal_string \"next skew under threshold\""
+                                                },
+                                                "value": "next skew under threshold"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_bfce3553988e17149500ee032e0a7bd1a3a5ca7057ec0b42e704d83d2f58912f",
+                                                    "typeString": "literal_string \"next skew under threshold\""
+                                                }
+                                            ],
+                                            "id": 684,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "8056:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 690,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "8056:67:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 691,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "8056:67:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307863634330333530433230394636463031443037316333636463323065456235454534413733643830",
+                                                        "id": 697,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "8167:42:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0xccC0350C209F6F01D071c3cdc20eEb5EE4A73d80"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 696,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "8159:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 695,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "8159:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 698,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "8159:51:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "307866666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666",
+                                                "id": 699,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "8224:66:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_115792089237316195423570985008687907853269984665640564039457584007913129639935_by_1",
+                                                    "typeString": "int_const 1157...(70 digits omitted)...9935"
+                                                },
+                                                "value": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_115792089237316195423570985008687907853269984665640564039457584007913129639935_by_1",
+                                                    "typeString": "int_const 1157...(70 digits omitted)...9935"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 692,
+                                                "name": "USDC",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 54,
+                                                "src": "8133:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 694,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6390,
+                                            "src": "8133:12:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 700,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "8133:167:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 701,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "8133:167:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 706,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 702,
+                                                "name": "tradingStats",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 51,
+                                                "src": "8310:12:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                    "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                }
+                                            },
+                                            "id": 704,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "swapping",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 34,
+                                            "src": "8310:21:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "hexValue": "66616c7365",
+                                            "id": 705,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "bool",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "8334:5:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            },
+                                            "value": "false"
+                                        },
+                                        "src": "8310:29:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 707,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "8310:29:0"
+                                },
+                                {
+                                    "assignments": [709],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 709,
+                                            "mutability": "mutable",
+                                            "name": "args",
+                                            "nameLocation": "8357:4:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 765,
+                                            "src": "8349:12:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 708,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "8349:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 719,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 712,
+                                                "name": "_amount",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 657,
+                                                "src": "8391:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            {
+                                                "expression": {
+                                                    "expression": {
+                                                        "id": 713,
+                                                        "name": "IPoolCommitter",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 1935,
+                                                        "src": "8400:14:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_contract$_IPoolCommitter_$1935_$",
+                                                            "typeString": "type(contract IPoolCommitter)"
+                                                        }
+                                                    },
+                                                    "id": 714,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "CommitType",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 1640,
+                                                    "src": "8400:25:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_enum$_CommitType_$1640_$",
+                                                        "typeString": "type(enum IPoolCommitter.CommitType)"
+                                                    }
+                                                },
+                                                "id": 715,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "memberName": "LongMint",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 1636,
+                                                "src": "8400:34:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_enum$_CommitType_$1640",
+                                                    "typeString": "enum IPoolCommitter.CommitType"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "66616c7365",
+                                                "id": 716,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "8436:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "false"
+                                            },
+                                            {
+                                                "hexValue": "74727565",
+                                                "id": 717,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "8443:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "true"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_enum$_CommitType_$1640",
+                                                    "typeString": "enum IPoolCommitter.CommitType"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 710,
+                                                "name": "encoder",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 82,
+                                                "src": "8364:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_L2Encoder_$2019",
+                                                    "typeString": "contract L2Encoder"
+                                                }
+                                            },
+                                            "id": 711,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "encodeCommitParams",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 2018,
+                                            "src": "8364:26:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_pure$_t_uint256_$_t_enum$_CommitType_$1640_$_t_bool_$_t_bool_$returns$_t_bytes32_$",
+                                                "typeString": "function (uint256,enum IPoolCommitter.CommitType,bool,bool) pure external returns (bytes32)"
+                                            }
+                                        },
+                                        "id": 718,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "8364:84:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "8349:99:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 723,
+                                                "name": "args",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 709,
+                                                "src": "8479:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 720,
+                                                "name": "poolCommitter",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 60,
+                                                "src": "8458:13:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                    "typeString": "contract IPoolCommitter"
+                                                }
+                                            },
+                                            "id": 722,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "commit",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1845,
+                                            "src": "8458:20:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_payable$_t_bytes32_$returns$__$",
+                                                "typeString": "function (bytes32) payable external"
+                                            }
+                                        },
+                                        "id": 724,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "8458:26:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 725,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "8458:26:0"
+                                },
+                                {
+                                    "eventCall": {
+                                        "arguments": [
+                                            {
+                                                "id": 727,
+                                                "name": "_amount",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 657,
+                                                "src": "8508:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "id": 726,
+                                            "name": "acquired",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 94,
+                                            "src": "8499:8:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_event_nonpayable$_t_uint256_$returns$__$",
+                                                "typeString": "function (uint256)"
+                                            }
+                                        },
+                                        "id": 728,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "8499:17:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 729,
+                                    "nodeType": "EmitStatement",
+                                    "src": "8494:22:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 738,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 730,
+                                                "name": "tradingStats",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 51,
+                                                "src": "8526:12:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                    "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                }
+                                            },
+                                            "id": 732,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "amtLong",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 40,
+                                            "src": "8526:20:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 736,
+                                                    "name": "_amount",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 657,
+                                                    "src": "8574:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "expression": {
+                                                        "id": 733,
+                                                        "name": "tradingStats",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 51,
+                                                        "src": "8549:12:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                            "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                        }
+                                                    },
+                                                    "id": 734,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "amtLong",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 40,
+                                                    "src": "8549:20:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 735,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "add",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5628,
+                                                "src": "8549:24:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                    "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                                }
+                                            },
+                                            "id": 737,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "8549:33:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "8526:56:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 739,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "8526:56:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 748,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 740,
+                                                "name": "tradingStats",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 51,
+                                                "src": "8592:12:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                    "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                }
+                                            },
+                                            "id": 742,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "want",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 42,
+                                            "src": "8592:17:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 746,
+                                                    "name": "_amount",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 657,
+                                                    "src": "8634:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "expression": {
+                                                        "id": 743,
+                                                        "name": "tradingStats",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 51,
+                                                        "src": "8612:12:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                            "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                        }
+                                                    },
+                                                    "id": 744,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "want",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 42,
+                                                    "src": "8612:17:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 745,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "sub",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5643,
+                                                "src": "8612:21:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                    "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                                }
+                                            },
+                                            "id": 747,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "8612:30:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "8592:50:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 749,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "8592:50:0"
+                                },
+                                {
+                                    "expression": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 754,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "expression": {
+                                                    "id": 750,
+                                                    "name": "tradingStats",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 51,
+                                                    "src": "8652:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                        "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                    }
+                                                },
+                                                "id": 752,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "want",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 42,
+                                                "src": "8652:17:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "hexValue": "30",
+                                                "id": 753,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "8672:1:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                    "typeString": "int_const 0"
+                                                },
+                                                "value": "0"
+                                            },
+                                            "src": "8652:21:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "id": 762,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftHandSide": {
+                                                "expression": {
+                                                    "id": 759,
+                                                    "name": "tradingStats",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 51,
+                                                    "src": "8707:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                        "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                    }
+                                                },
+                                                "id": 760,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": true,
+                                                "memberName": "swapping",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 34,
+                                                "src": "8707:21:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            "nodeType": "Assignment",
+                                            "operator": "=",
+                                            "rightHandSide": {
+                                                "hexValue": "66616c7365",
+                                                "id": 761,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "8731:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "false"
+                                            },
+                                            "src": "8707:29:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "id": 763,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "8652:84:0",
+                                        "trueExpression": {
+                                            "id": 758,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftHandSide": {
+                                                "expression": {
+                                                    "id": 755,
+                                                    "name": "tradingStats",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 51,
+                                                    "src": "8676:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                        "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                    }
+                                                },
+                                                "id": 756,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": true,
+                                                "memberName": "swapping",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 34,
+                                                "src": "8676:21:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            "nodeType": "Assignment",
+                                            "operator": "=",
+                                            "rightHandSide": {
+                                                "hexValue": "74727565",
+                                                "id": 757,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "8700:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "true"
+                                            },
+                                            "src": "8676:28:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 764,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "8652:84:0"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 655,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "7571:192:0",
+                            "text": " @notice Aquires long tokens for the vault from the poolCommitter\n @dev only call when swaps cant fulfil wants\n @param _amount amount of long tokens to be aquired"
+                        },
+                        "functionSelector": "20889d3b",
+                        "id": 766,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "acquire",
+                        "nameLocation": "7777:7:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 658,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 657,
+                                    "mutability": "mutable",
+                                    "name": "_amount",
+                                    "nameLocation": "7793:7:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 766,
+                                    "src": "7785:15:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 656,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7785:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "7784:17:0"
+                        },
+                        "returnParameters": {
+                            "id": 659,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "7809:0:0"
+                        },
+                        "scope": 1134,
+                        "src": "7768:975:0",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 802,
+                            "nodeType": "Block",
+                            "src": "9024:199:0",
+                            "statements": [
+                                {
+                                    "assignments": [775],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 775,
+                                            "mutability": "mutable",
+                                            "name": "lTokens",
+                                            "nameLocation": "9042:7:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 802,
+                                            "src": "9034:15:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 774,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "9034:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 784,
+                                    "initialValue": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 780,
+                                                            "name": "this",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -28,
+                                                            "src": "9094:4:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                "typeString": "contract LongFarmer"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                "typeString": "contract LongFarmer"
+                                                            }
+                                                        ],
+                                                        "id": 779,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "9086:7:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_address_$",
+                                                            "typeString": "type(address)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 778,
+                                                            "name": "address",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "9086:7:0",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    },
+                                                    "id": 781,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "typeConversion",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9086:13:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "id": 776,
+                                                    "name": "poolCommitter",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 60,
+                                                    "src": "9052:13:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                        "typeString": "contract IPoolCommitter"
+                                                    }
+                                                },
+                                                "id": 777,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "getAggregateBalance",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 1904,
+                                                "src": "9052:33:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_struct$_Balance_$1696_memory_ptr_$",
+                                                    "typeString": "function (address) view external returns (struct IPoolCommitter.Balance memory)"
+                                                }
+                                            },
+                                            "id": 782,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "9052:48:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_Balance_$1696_memory_ptr",
+                                                "typeString": "struct IPoolCommitter.Balance memory"
+                                            }
+                                        },
+                                        "id": 783,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "longTokens",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 1691,
+                                        "src": "9052:59:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "9034:77:0"
+                                },
+                                {
+                                    "assignments": [786],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 786,
+                                            "mutability": "mutable",
+                                            "name": "_bool",
+                                            "nameLocation": "9126:5:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 802,
+                                            "src": "9121:10:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            },
+                                            "typeName": {
+                                                "id": 785,
+                                                "name": "bool",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "9121:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 788,
+                                    "initialValue": {
+                                        "hexValue": "66616c7365",
+                                        "id": 787,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": true,
+                                        "kind": "bool",
+                                        "lValueRequested": false,
+                                        "nodeType": "Literal",
+                                        "src": "9134:5:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        },
+                                        "value": "false"
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "9121:18:0"
+                                },
+                                {
+                                    "expression": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 791,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 789,
+                                                "name": "lTokens",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 775,
+                                                "src": "9149:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 790,
+                                                "name": "_amt",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 769,
+                                                "src": "9159:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "9149:14:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "id": 797,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftHandSide": {
+                                                "id": 795,
+                                                "name": "_bool",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 786,
+                                                "src": "9181:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            "nodeType": "Assignment",
+                                            "operator": "=",
+                                            "rightHandSide": {
+                                                "hexValue": "66616c7365",
+                                                "id": 796,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "9189:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "false"
+                                            },
+                                            "src": "9181:13:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "id": 798,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "9149:45:0",
+                                        "trueExpression": {
+                                            "id": 794,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftHandSide": {
+                                                "id": 792,
+                                                "name": "_bool",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 786,
+                                                "src": "9166:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            "nodeType": "Assignment",
+                                            "operator": "=",
+                                            "rightHandSide": {
+                                                "hexValue": "74727565",
+                                                "id": 793,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "9174:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "true"
+                                            },
+                                            "src": "9166:12:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 799,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "9149:45:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 800,
+                                        "name": "_bool",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 786,
+                                        "src": "9211:5:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "functionReturnParameters": 773,
+                                    "id": 801,
+                                    "nodeType": "Return",
+                                    "src": "9204:12:0"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 767,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "8749:214:0",
+                            "text": " @notice Checks committer aggregate balance, returns bool\n @dev if long tokens in aggregate balance are greater than amt, returns true\n @param _amt amount of long tokens to be released"
+                        },
+                        "functionSelector": "e197f107",
+                        "id": 803,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "agBal",
+                        "nameLocation": "8977:5:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 770,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 769,
+                                    "mutability": "mutable",
+                                    "name": "_amt",
+                                    "nameLocation": "8991:4:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 803,
+                                    "src": "8983:12:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 768,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "8983:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "8982:14:0"
+                        },
+                        "returnParameters": {
+                            "id": 773,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 772,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 803,
+                                    "src": "9018:4:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 771,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9018:4:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "9017:6:0"
+                        },
+                        "scope": 1134,
+                        "src": "8968:255:0",
+                        "stateMutability": "view",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 872,
+                            "nodeType": "Block",
+                            "src": "9536:451:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_enum$_State_$24",
+                                                    "typeString": "enum LongFarmer.State"
+                                                },
+                                                "id": 815,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "id": 812,
+                                                    "name": "state",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 48,
+                                                    "src": "9554:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_enum$_State_$24",
+                                                        "typeString": "enum LongFarmer.State"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "expression": {
+                                                        "id": 813,
+                                                        "name": "State",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 24,
+                                                        "src": "9563:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_enum$_State_$24_$",
+                                                            "typeString": "type(enum LongFarmer.State)"
+                                                        }
+                                                    },
+                                                    "id": 814,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "memberName": "Active",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 23,
+                                                    "src": "9563:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_enum$_State_$24",
+                                                        "typeString": "enum LongFarmer.State"
+                                                    }
+                                                },
+                                                "src": "9554:21:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "7661756c74206d7573742062652061637469766520746f20646973706f7365",
+                                                "id": 816,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "9577:33:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_14bb9c44f096a237cd0503f0404d75ef308cd1118bf5e31e5b8192c848310de5",
+                                                    "typeString": "literal_string \"vault must be active to dispose\""
+                                                },
+                                                "value": "vault must be active to dispose"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_14bb9c44f096a237cd0503f0404d75ef308cd1118bf5e31e5b8192c848310de5",
+                                                    "typeString": "literal_string \"vault must be active to dispose\""
+                                                }
+                                            ],
+                                            "id": 811,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "9546:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 817,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "9546:65:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 818,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "9546:65:0"
+                                },
+                                {
+                                    "assignments": [820],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 820,
+                                            "mutability": "mutable",
+                                            "name": "args",
+                                            "nameLocation": "9629:4:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 872,
+                                            "src": "9621:12:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 819,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "9621:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 830,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 823,
+                                                "name": "_amount",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 806,
+                                                "src": "9663:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            {
+                                                "expression": {
+                                                    "expression": {
+                                                        "id": 824,
+                                                        "name": "IPoolCommitter",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 1935,
+                                                        "src": "9672:14:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_contract$_IPoolCommitter_$1935_$",
+                                                            "typeString": "type(contract IPoolCommitter)"
+                                                        }
+                                                    },
+                                                    "id": 825,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "CommitType",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 1640,
+                                                    "src": "9672:25:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_enum$_CommitType_$1640_$",
+                                                        "typeString": "type(enum IPoolCommitter.CommitType)"
+                                                    }
+                                                },
+                                                "id": 826,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "memberName": "LongBurn",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 1637,
+                                                "src": "9672:34:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_enum$_CommitType_$1640",
+                                                    "typeString": "enum IPoolCommitter.CommitType"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "66616c7365",
+                                                "id": 827,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "9708:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "false"
+                                            },
+                                            {
+                                                "hexValue": "66616c7365",
+                                                "id": 828,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "9715:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "false"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_enum$_CommitType_$1640",
+                                                    "typeString": "enum IPoolCommitter.CommitType"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 821,
+                                                "name": "encoder",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 82,
+                                                "src": "9636:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_L2Encoder_$2019",
+                                                    "typeString": "contract L2Encoder"
+                                                }
+                                            },
+                                            "id": 822,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "encodeCommitParams",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 2018,
+                                            "src": "9636:26:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_pure$_t_uint256_$_t_enum$_CommitType_$1640_$_t_bool_$_t_bool_$returns$_t_bytes32_$",
+                                                "typeString": "function (uint256,enum IPoolCommitter.CommitType,bool,bool) pure external returns (bytes32)"
+                                            }
+                                        },
+                                        "id": 829,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "9636:85:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "9621:100:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 834,
+                                                "name": "args",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 820,
+                                                "src": "9752:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 831,
+                                                "name": "poolCommitter",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 60,
+                                                "src": "9731:13:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_IPoolCommitter_$1935",
+                                                    "typeString": "contract IPoolCommitter"
+                                                }
+                                            },
+                                            "id": 833,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "commit",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1845,
+                                            "src": "9731:20:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_payable$_t_bytes32_$returns$__$",
+                                                "typeString": "function (bytes32) payable external"
+                                            }
+                                        },
+                                        "id": 835,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "9731:26:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 836,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "9731:26:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 845,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 837,
+                                                "name": "tradingStats",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 51,
+                                                "src": "9767:12:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                    "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                }
+                                            },
+                                            "id": 839,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "want",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 42,
+                                            "src": "9767:17:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 843,
+                                                    "name": "_amount",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 806,
+                                                    "src": "9809:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "expression": {
+                                                        "id": 840,
+                                                        "name": "tradingStats",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 51,
+                                                        "src": "9787:12:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                            "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                        }
+                                                    },
+                                                    "id": 841,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "want",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 42,
+                                                    "src": "9787:17:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 842,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "sub",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5643,
+                                                "src": "9787:21:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                    "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                                }
+                                            },
+                                            "id": 844,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "9787:30:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "9767:50:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 846,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "9767:50:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 855,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 847,
+                                                "name": "tradingStats",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 51,
+                                                "src": "9827:12:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                    "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                }
+                                            },
+                                            "id": 849,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "amtLong",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 40,
+                                            "src": "9827:20:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 853,
+                                                    "name": "_amount",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 806,
+                                                    "src": "9875:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "expression": {
+                                                        "id": 850,
+                                                        "name": "tradingStats",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 51,
+                                                        "src": "9850:12:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                            "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                        }
+                                                    },
+                                                    "id": 851,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "amtLong",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 40,
+                                                    "src": "9850:20:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 852,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "sub",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5643,
+                                                "src": "9850:24:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                    "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                                }
+                                            },
+                                            "id": 854,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "9850:33:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "9827:56:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 856,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "9827:56:0"
+                                },
+                                {
+                                    "expression": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 861,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "expression": {
+                                                    "id": 857,
+                                                    "name": "tradingStats",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 51,
+                                                    "src": "9893:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                        "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                    }
+                                                },
+                                                "id": 859,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "want",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 42,
+                                                "src": "9893:17:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "hexValue": "31303030",
+                                                "id": 860,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "9913:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000_by_1",
+                                                    "typeString": "int_const 1000"
+                                                },
+                                                "value": "1000"
+                                            },
+                                            "src": "9893:24:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "id": 869,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftHandSide": {
+                                                "expression": {
+                                                    "id": 866,
+                                                    "name": "tradingStats",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 51,
+                                                    "src": "9951:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                        "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                    }
+                                                },
+                                                "id": 867,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": true,
+                                                "memberName": "swapping",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 34,
+                                                "src": "9951:21:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            "nodeType": "Assignment",
+                                            "operator": "=",
+                                            "rightHandSide": {
+                                                "hexValue": "66616c7365",
+                                                "id": 868,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "9975:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "false"
+                                            },
+                                            "src": "9951:29:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "id": 870,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "9893:87:0",
+                                        "trueExpression": {
+                                            "id": 865,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftHandSide": {
+                                                "expression": {
+                                                    "id": 862,
+                                                    "name": "tradingStats",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 51,
+                                                    "src": "9920:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                        "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                    }
+                                                },
+                                                "id": 863,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": true,
+                                                "memberName": "swapping",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 34,
+                                                "src": "9920:21:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            "nodeType": "Assignment",
+                                            "operator": "=",
+                                            "rightHandSide": {
+                                                "hexValue": "74727565",
+                                                "id": 864,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "9944:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "true"
+                                            },
+                                            "src": "9920:28:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 871,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "9893:87:0"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 804,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "9229:250:0",
+                            "text": " @notice Releases long tokens to the poolCommitter\n @dev only call when forcing disposal of long tokens\n @param _amount amount of long tokens to be released\n @dev must be set as role based access when in production"
+                        },
+                        "functionSelector": "57214eb0",
+                        "id": 873,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [
+                            {
+                                "id": 809,
+                                "kind": "modifierInvocation",
+                                "modifierName": {
+                                    "id": 808,
+                                    "name": "onlyPlayer",
+                                    "nodeType": "IdentifierPath",
+                                    "referencedDeclaration": 1106,
+                                    "src": "9525:10:0"
+                                },
+                                "nodeType": "ModifierInvocation",
+                                "src": "9525:10:0"
+                            }
+                        ],
+                        "name": "dispose",
+                        "nameLocation": "9493:7:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 807,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 806,
+                                    "mutability": "mutable",
+                                    "name": "_amount",
+                                    "nameLocation": "9509:7:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 873,
+                                    "src": "9501:15:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 805,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9501:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "9500:17:0"
+                        },
+                        "returnParameters": {
+                            "id": 810,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "9536:0:0"
+                        },
+                        "scope": 1134,
+                        "src": "9484:503:0",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 963,
+                            "nodeType": "Block",
+                            "src": "10324:568:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_enum$_State_$24",
+                                                    "typeString": "enum LongFarmer.State"
+                                                },
+                                                "id": 889,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "id": 886,
+                                                    "name": "state",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 48,
+                                                    "src": "10342:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_enum$_State_$24",
+                                                        "typeString": "enum LongFarmer.State"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "expression": {
+                                                        "id": 887,
+                                                        "name": "State",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 24,
+                                                        "src": "10351:5:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_enum$_State_$24_$",
+                                                            "typeString": "type(enum LongFarmer.State)"
+                                                        }
+                                                    },
+                                                    "id": 888,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "memberName": "Active",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 23,
+                                                    "src": "10351:12:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_enum$_State_$24",
+                                                        "typeString": "enum LongFarmer.State"
+                                                    }
+                                                },
+                                                "src": "10342:21:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "5661756c74206973206e6f7420616374697665",
+                                                "id": 890,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "10365:21:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_b319238b6a177b3e8719985b7ae4ddbf50bb02cee75c1bcba32ad9cf7735f6f0",
+                                                    "typeString": "literal_string \"Vault is not active\""
+                                                },
+                                                "value": "Vault is not active"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_b319238b6a177b3e8719985b7ae4ddbf50bb02cee75c1bcba32ad9cf7735f6f0",
+                                                    "typeString": "literal_string \"Vault is not active\""
+                                                }
+                                            ],
+                                            "id": 885,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "10334:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 891,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "10334:53:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 892,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "10334:53:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "id": 897,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 894,
+                                                        "name": "tradingStats",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 51,
+                                                        "src": "10405:12:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                            "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                        }
+                                                    },
+                                                    "id": 895,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "unWinding",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 36,
+                                                    "src": "10405:22:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "hexValue": "66616c7365",
+                                                    "id": 896,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "bool",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "10431:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    },
+                                                    "value": "false"
+                                                },
+                                                "src": "10405:31:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "5661756c7420697320756e77696e64696e67",
+                                                "id": 898,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "10438:20:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_20f5ee24cf8a860db161d8b967f062c432b583a917cd3f61491c930e60dae426",
+                                                    "typeString": "literal_string \"Vault is unwinding\""
+                                                },
+                                                "value": "Vault is unwinding"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_20f5ee24cf8a860db161d8b967f062c432b583a917cd3f61491c930e60dae426",
+                                                    "typeString": "literal_string \"Vault is unwinding\""
+                                                }
+                                            ],
+                                            "id": 893,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "10397:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 899,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "10397:62:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 900,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "10397:62:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "id": 905,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 902,
+                                                        "name": "tradingStats",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 51,
+                                                        "src": "10477:12:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                            "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                        }
+                                                    },
+                                                    "id": 903,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "swapping",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 34,
+                                                    "src": "10477:21:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "hexValue": "74727565",
+                                                    "id": 904,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "bool",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "10502:4:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    },
+                                                    "value": "true"
+                                                },
+                                                "src": "10477:29:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "5661756c74206973206e6f74207377617070696e67",
+                                                "id": 906,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "10508:23:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_5a68be460723f8c2e8ab3fee1b7609b5466d0c633f5d681f9dc201901b0e6da8",
+                                                    "typeString": "literal_string \"Vault is not swapping\""
+                                                },
+                                                "value": "Vault is not swapping"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_5a68be460723f8c2e8ab3fee1b7609b5466d0c633f5d681f9dc201901b0e6da8",
+                                                    "typeString": "literal_string \"Vault is not swapping\""
+                                                }
+                                            ],
+                                            "id": 901,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "10469:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 907,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "10469:63:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 908,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "10469:63:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 914,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "10568:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 913,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "10560:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 912,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "10560:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 915,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "10560:13:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 916,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "10575:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 909,
+                                                "name": "longToken",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 57,
+                                                "src": "10542:9:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 911,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6390,
+                                            "src": "10542:17:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 917,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "10542:38:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 918,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "10542:38:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "expression": {
+                                                            "id": 924,
+                                                            "name": "msg",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -15,
+                                                            "src": "10621:3:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_message",
+                                                                "typeString": "msg"
+                                                            }
+                                                        },
+                                                        "id": 925,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "sender",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "10621:10:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 923,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "10613:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 922,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "10613:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 926,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "10613:19:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 929,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "10642:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 928,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "10634:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 927,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "10634:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 930,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "10634:13:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 931,
+                                                "name": "_amtLong",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 876,
+                                                "src": "10649:8:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 919,
+                                                "name": "longToken",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 57,
+                                                "src": "10590:9:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 921,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "transferFrom",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6484,
+                                            "src": "10590:22:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 932,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "10590:68:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 933,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "10590:68:0"
+                                },
+                                {
+                                    "assignments": [935],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 935,
+                                            "mutability": "mutable",
+                                            "name": "_out",
+                                            "nameLocation": "10676:4:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 963,
+                                            "src": "10668:12:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 934,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "10668:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 941,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 939,
+                                                "name": "_amtLong",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 876,
+                                                "src": "10704:8:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [],
+                                                "expression": {
+                                                    "argumentTypes": [],
+                                                    "id": 936,
+                                                    "name": "longTokenPrice",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 996,
+                                                    "src": "10683:14:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_view$__$returns$_t_uint256_$",
+                                                        "typeString": "function () view returns (uint256)"
+                                                    }
+                                                },
+                                                "id": 937,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "10683:16:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "id": 938,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "mul",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5658,
+                                            "src": "10683:20:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                            }
+                                        },
+                                        "id": 940,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "10683:30:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "10668:45:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "expression": {
+                                                            "id": 948,
+                                                            "name": "msg",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -15,
+                                                            "src": "10790:3:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_message",
+                                                                "typeString": "msg"
+                                                            }
+                                                        },
+                                                        "id": 949,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "sender",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "10790:10:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 947,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "10782:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 946,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "10782:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 950,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "10782:19:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 951,
+                                                "name": "_out",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 935,
+                                                "src": "10803:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                        "id": 943,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "10729:42:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 942,
+                                                    "name": "ERC20",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 6673,
+                                                    "src": "10723:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_contract$_ERC20_$6673_$",
+                                                        "typeString": "type(contract ERC20)"
+                                                    }
+                                                },
+                                                "id": 944,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "10723:49:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 945,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "transfer",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6423,
+                                            "src": "10723:58:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 952,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "10723:85:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 953,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "10723:85:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 957,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "id": 955,
+                                                    "name": "_out",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 935,
+                                                    "src": "10826:4:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": ">",
+                                                "rightExpression": {
+                                                    "id": 956,
+                                                    "name": "_minAmtUSDC",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 878,
+                                                    "src": "10833:11:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "10826:18:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "4e6f7420656e6f7567682055534443",
+                                                "id": 958,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "10846:17:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_716b6a1cd495d137021b8166098a526218c5074f07af981256a5686174be6c0c",
+                                                    "typeString": "literal_string \"Not enough USDC\""
+                                                },
+                                                "value": "Not enough USDC"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_716b6a1cd495d137021b8166098a526218c5074f07af981256a5686174be6c0c",
+                                                    "typeString": "literal_string \"Not enough USDC\""
+                                                }
+                                            ],
+                                            "id": 954,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "10818:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 959,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "10818:46:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 960,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "10818:46:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 961,
+                                        "name": "_out",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 935,
+                                        "src": "10881:4:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "functionReturnParameters": 884,
+                                    "id": 962,
+                                    "nodeType": "Return",
+                                    "src": "10874:11:0"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 874,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "9993:232:0",
+                            "text": " @notice swap function allowing users to swap longTokens for USDC\n @dev MUST revert when not skewed\n @param _amtLong long tokens to be swapped\n @param _minAmtUSDC minimum amount of USDC to recieve"
+                        },
+                        "functionSelector": "70437125",
+                        "id": 964,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [
+                            {
+                                "id": 881,
+                                "kind": "modifierInvocation",
+                                "modifierName": {
+                                    "id": 880,
+                                    "name": "onlyWhenSkewed",
+                                    "nodeType": "IdentifierPath",
+                                    "referencedDeclaration": 1118,
+                                    "src": "10291:14:0"
+                                },
+                                "nodeType": "ModifierInvocation",
+                                "src": "10291:14:0"
+                            }
+                        ],
+                        "name": "_swap",
+                        "nameLocation": "10239:5:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 879,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 876,
+                                    "mutability": "mutable",
+                                    "name": "_amtLong",
+                                    "nameLocation": "10253:8:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 964,
+                                    "src": "10245:16:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 875,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10245:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 878,
+                                    "mutability": "mutable",
+                                    "name": "_minAmtUSDC",
+                                    "nameLocation": "10271:11:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 964,
+                                    "src": "10263:19:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 877,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10263:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "10244:39:0"
+                        },
+                        "returnParameters": {
+                            "id": 884,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 883,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 964,
+                                    "src": "10315:7:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 882,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10315:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "10314:9:0"
+                        },
+                        "scope": 1134,
+                        "src": "10230:662:0",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 995,
+                            "nodeType": "Block",
+                            "src": "11059:212:0",
+                            "statements": [
+                                {
+                                    "assignments": [971],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 971,
+                                            "mutability": "mutable",
+                                            "name": "bal",
+                                            "nameLocation": "11077:3:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 995,
+                                            "src": "11069:11:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 970,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "11069:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 975,
+                                    "initialValue": {
+                                        "arguments": [],
+                                        "expression": {
+                                            "argumentTypes": [],
+                                            "expression": {
+                                                "id": 972,
+                                                "name": "pool",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 79,
+                                                "src": "11083:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ILeveragedPool_$1630",
+                                                    "typeString": "contract ILeveragedPool"
+                                                }
+                                            },
+                                            "id": 973,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "longBalance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1497,
+                                            "src": "11083:16:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$",
+                                                "typeString": "function () view external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 974,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "11083:18:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "11069:32:0"
+                                },
+                                {
+                                    "assignments": [977],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 977,
+                                            "mutability": "mutable",
+                                            "name": "price",
+                                            "nameLocation": "11119:5:0",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 995,
+                                            "src": "11111:13:0",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 976,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "11111:7:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 984,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [],
+                                                "expression": {
+                                                    "argumentTypes": [],
+                                                    "expression": {
+                                                        "id": 980,
+                                                        "name": "longToken",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 57,
+                                                        "src": "11135:9:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                            "typeString": "contract ERC20"
+                                                        }
+                                                    },
+                                                    "id": 981,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "totalSupply",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 6312,
+                                                    "src": "11135:21:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$",
+                                                        "typeString": "function () view external returns (uint256)"
+                                                    }
+                                                },
+                                                "id": 982,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "11135:23:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 978,
+                                                "name": "bal",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 971,
+                                                "src": "11127:3:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "id": 979,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "div",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5673,
+                                            "src": "11127:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$",
+                                                "typeString": "function (uint256,uint256) pure returns (uint256)"
+                                            }
+                                        },
+                                        "id": 983,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "11127:32:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "11111:48:0"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 987,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 985,
+                                            "name": "price",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 977,
+                                            "src": "11173:5:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 986,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "11182:1:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "11173:10:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "falseBody": {
+                                        "id": 993,
+                                        "nodeType": "Block",
+                                        "src": "11228:37:0",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "id": 991,
+                                                    "name": "price",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 977,
+                                                    "src": "11249:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "functionReturnParameters": 969,
+                                                "id": 992,
+                                                "nodeType": "Return",
+                                                "src": "11242:12:0"
+                                            }
+                                        ]
+                                    },
+                                    "id": 994,
+                                    "nodeType": "IfStatement",
+                                    "src": "11169:96:0",
+                                    "trueBody": {
+                                        "id": 990,
+                                        "nodeType": "Block",
+                                        "src": "11185:37:0",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "hexValue": "3130303030",
+                                                    "id": 988,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "11206:5:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_10000_by_1",
+                                                        "typeString": "int_const 10000"
+                                                    },
+                                                    "value": "10000"
+                                                },
+                                                "functionReturnParameters": 969,
+                                                "id": 989,
+                                                "nodeType": "Return",
+                                                "src": "11199:12:0"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 965,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "10898:100:0",
+                            "text": " @notice getter for long token price\n @notice remove when not testing"
+                        },
+                        "functionSelector": "047d6665",
+                        "id": 996,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "longTokenPrice",
+                        "nameLocation": "11012:14:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 966,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "11026:2:0"
+                        },
+                        "returnParameters": {
+                            "id": 969,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 968,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 996,
+                                    "src": "11050:7:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 967,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "11050:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "11049:9:0"
+                        },
+                        "scope": 1134,
+                        "src": "11003:268:0",
+                        "stateMutability": "view",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 1019,
+                            "nodeType": "Block",
+                            "src": "11386:112:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 1005,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 1002,
+                                            "name": "state",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 48,
+                                            "src": "11396:5:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_enum$_State_$24",
+                                                "typeString": "enum LongFarmer.State"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "expression": {
+                                                "id": 1003,
+                                                "name": "State",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 24,
+                                                "src": "11404:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_enum$_State_$24_$",
+                                                    "typeString": "type(enum LongFarmer.State)"
+                                                }
+                                            },
+                                            "id": 1004,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "Active",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 23,
+                                            "src": "11404:12:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_enum$_State_$24",
+                                                "typeString": "enum LongFarmer.State"
+                                            }
+                                        },
+                                        "src": "11396:20:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_enum$_State_$24",
+                                            "typeString": "enum LongFarmer.State"
+                                        }
+                                    },
+                                    "id": 1006,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "11396:20:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 1011,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 1007,
+                                                "name": "tradingStats",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 51,
+                                                "src": "11426:12:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                    "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                }
+                                            },
+                                            "id": 1009,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "swapping",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 34,
+                                            "src": "11426:21:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "hexValue": "74727565",
+                                            "id": 1010,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "bool",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "11450:4:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            },
+                                            "value": "true"
+                                        },
+                                        "src": "11426:28:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 1012,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "11426:28:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 1017,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 1013,
+                                                "name": "tradingStats",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 51,
+                                                "src": "11464:12:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_TradingStats_$45_storage",
+                                                    "typeString": "struct LongFarmer.TradingStats storage ref"
+                                                }
+                                            },
+                                            "id": 1015,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "testing",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 44,
+                                            "src": "11464:20:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "hexValue": "74727565",
+                                            "id": 1016,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "bool",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "11487:4:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            },
+                                            "value": "true"
+                                        },
+                                        "src": "11464:27:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 1018,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "11464:27:0"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 997,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "11277:66:0",
+                            "text": " @notice Setter for Testing purposes only"
+                        },
+                        "functionSelector": "760a8c2a",
+                        "id": 1020,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [
+                            {
+                                "id": 1000,
+                                "kind": "modifierInvocation",
+                                "modifierName": {
+                                    "id": 999,
+                                    "name": "onlyOwner",
+                                    "nodeType": "IdentifierPath",
+                                    "referencedDeclaration": 3853,
+                                    "src": "11376:9:0"
+                                },
+                                "nodeType": "ModifierInvocation",
+                                "src": "11376:9:0"
+                            }
+                        ],
+                        "name": "setActive",
+                        "nameLocation": "11357:9:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 998,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "11366:2:0"
+                        },
+                        "returnParameters": {
+                            "id": 1001,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "11386:0:0"
+                        },
+                        "scope": 1134,
+                        "src": "11348:150:0",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 1047,
+                            "nodeType": "Block",
+                            "src": "11549:125:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 1029,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 1025,
+                                            "name": "skewVault",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 66,
+                                            "src": "11559:9:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                "typeString": "contract SkewVault"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 1027,
+                                                    "name": "_vault",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 1022,
+                                                    "src": "11581:6:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 1026,
+                                                "name": "SkewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1326,
+                                                "src": "11571:9:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_contract$_SkewVault_$1326_$",
+                                                    "typeString": "type(contract SkewVault)"
+                                                }
+                                            },
+                                            "id": 1028,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "11571:17:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                "typeString": "contract SkewVault"
+                                            }
+                                        },
+                                        "src": "11559:29:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                            "typeString": "contract SkewVault"
+                                        }
+                                    },
+                                    "id": 1030,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "11559:29:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 1035,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 1031,
+                                            "name": "vault",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 63,
+                                            "src": "11598:5:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                "typeString": "contract ERC20"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 1033,
+                                                    "name": "_vault",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 1022,
+                                                    "src": "11612:6:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 1032,
+                                                "name": "ERC20",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6673,
+                                                "src": "11606:5:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_contract$_ERC20_$6673_$",
+                                                    "typeString": "type(contract ERC20)"
+                                                }
+                                            },
+                                            "id": 1034,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "11606:13:0",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                "typeString": "contract ERC20"
+                                            }
+                                        },
+                                        "src": "11598:21:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                                            "typeString": "contract ERC20"
+                                        }
+                                    },
+                                    "id": 1036,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "11598:21:0"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 1042,
+                                                        "name": "skewVault",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 66,
+                                                        "src": "11650:9:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    ],
+                                                    "id": 1041,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "11642:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 1040,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "11642:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 1043,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "11642:18:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 1044,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "11662:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 1037,
+                                                "name": "USDC",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 54,
+                                                "src": "11629:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 1039,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6390,
+                                            "src": "11629:12:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 1045,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "11629:38:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 1046,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "11629:38:0"
+                                }
+                            ]
+                        },
+                        "functionSelector": "168ba808",
+                        "id": 1048,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "setSkewVault",
+                        "nameLocation": "11513:12:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 1023,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 1022,
+                                    "mutability": "mutable",
+                                    "name": "_vault",
+                                    "nameLocation": "11534:6:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1048,
+                                    "src": "11526:14:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 1021,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "11526:7:0",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "11525:16:0"
+                        },
+                        "returnParameters": {
+                            "id": 1024,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "11549:0:0"
+                        },
+                        "scope": 1134,
+                        "src": "11504:170:0",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 1071,
+                            "nodeType": "Block",
+                            "src": "11718:100:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 1058,
+                                                        "name": "skewVault",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 66,
+                                                        "src": "11754:9:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    ],
+                                                    "id": 1057,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "11746:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 1056,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "11746:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 1059,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "11746:18:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 1062,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "11774:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 1061,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "11766:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 1060,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "11766:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 1063,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "11766:13:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 1064,
+                                                "name": "_amt",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1050,
+                                                "src": "11781:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 1053,
+                                                "name": "USDC",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 54,
+                                                "src": "11728:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 1055,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "transferFrom",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6484,
+                                            "src": "11728:17:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 1065,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "11728:58:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 1066,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "11728:58:0"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 1069,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 1067,
+                                            "name": "depUSDC",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 76,
+                                            "src": "11796:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "+=",
+                                        "rightHandSide": {
+                                            "id": 1068,
+                                            "name": "_amt",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 1050,
+                                            "src": "11807:4:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "11796:15:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 1070,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "11796:15:0"
+                                }
+                            ]
+                        },
+                        "functionSelector": "3f36deec",
+                        "id": 1072,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "rxFunds",
+                        "nameLocation": "11689:7:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 1051,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 1050,
+                                    "mutability": "mutable",
+                                    "name": "_amt",
+                                    "nameLocation": "11705:4:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1072,
+                                    "src": "11697:12:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 1049,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "11697:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "11696:14:0"
+                        },
+                        "returnParameters": {
+                            "id": 1052,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "11718:0:0"
+                        },
+                        "scope": 1134,
+                        "src": "11680:138:0",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 1087,
+                            "nodeType": "Block",
+                            "src": "11868:58:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 1082,
+                                                        "name": "skewVault",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 66,
+                                                        "src": "11900:9:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    ],
+                                                    "id": 1081,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "11892:7:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 1080,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "11892:7:0",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 1083,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "11892:18:0",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 1084,
+                                                "name": "amount",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1074,
+                                                "src": "11912:6:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 1077,
+                                                "name": "USDC",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 54,
+                                                "src": "11878:4:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 1079,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "transfer",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6423,
+                                            "src": "11878:13:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 1085,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "11878:41:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 1086,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "11878:41:0"
+                                }
+                            ]
+                        },
+                        "functionSelector": "45755dd6",
+                        "id": 1088,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "returnFunds",
+                        "nameLocation": "11833:11:0",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 1075,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 1074,
+                                    "mutability": "mutable",
+                                    "name": "amount",
+                                    "nameLocation": "11853:6:0",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1088,
+                                    "src": "11845:14:0",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 1073,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "11845:7:0",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "11844:16:0"
+                        },
+                        "returnParameters": {
+                            "id": 1076,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "11868:0:0"
+                        },
+                        "scope": 1134,
+                        "src": "11824:102:0",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 1105,
+                            "nodeType": "Block",
+                            "src": "11954:104:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 1100,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "expression": {
+                                                                        "id": 1095,
+                                                                        "name": "msg",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": -15,
+                                                                        "src": "11996:3:0",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_magic_message",
+                                                                            "typeString": "msg"
+                                                                        }
+                                                                    },
+                                                                    "id": 1096,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "sender",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "src": "11996:10:0",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                ],
+                                                                "id": 1094,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "11988:7:0",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_address_$",
+                                                                    "typeString": "type(address)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 1093,
+                                                                    "name": "address",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "11988:7:0",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 1097,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "11988:19:0",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 1091,
+                                                            "name": "vault",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 63,
+                                                            "src": "11972:5:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                                "typeString": "contract ERC20"
+                                                            }
+                                                        },
+                                                        "id": 1092,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "balanceOf",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 6316,
+                                                        "src": "11972:15:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_uint256_$",
+                                                            "typeString": "function (address) view external returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 1098,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11972:36:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": ">",
+                                                "rightExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 1099,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "12011:1:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "src": "11972:40:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "4f6e6c7920706c617965722063616e2065786563757465",
+                                                "id": 1101,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "12014:25:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_ba7470894c38adfc63511d41ffe228958d489cc7005bae475c5d833a34b33772",
+                                                    "typeString": "literal_string \"Only player can execute\""
+                                                },
+                                                "value": "Only player can execute"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_ba7470894c38adfc63511d41ffe228958d489cc7005bae475c5d833a34b33772",
+                                                    "typeString": "literal_string \"Only player can execute\""
+                                                }
+                                            ],
+                                            "id": 1090,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "11964:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 1102,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "11964:76:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 1103,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "11964:76:0"
+                                },
+                                {
+                                    "id": 1104,
+                                    "nodeType": "PlaceholderStatement",
+                                    "src": "12050:1:0"
+                                }
+                            ]
+                        },
+                        "id": 1106,
+                        "name": "onlyPlayer",
+                        "nameLocation": "11941:10:0",
+                        "nodeType": "ModifierDefinition",
+                        "parameters": {
+                            "id": 1089,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "11951:2:0"
+                        },
+                        "src": "11932:126:0",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 1117,
+                            "nodeType": "Block",
+                            "src": "12090:80:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 1112,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 1109,
+                                                        "name": "skew",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 561,
+                                                        "src": "12108:4:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_view$__$returns$_t_uint256_$",
+                                                            "typeString": "function () view returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 1110,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "12108:6:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": ">",
+                                                "rightExpression": {
+                                                    "id": 1111,
+                                                    "name": "threshold",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 72,
+                                                    "src": "12117:9:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "12108:18:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "6f6e6c792073776170207768656e20736b65776564",
+                                                "id": 1113,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "12128:23:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_c772eac795b2a73bb558760c71d88a64d08acf1da8d941d348b2321ec783e645",
+                                                    "typeString": "literal_string \"only swap when skewed\""
+                                                },
+                                                "value": "only swap when skewed"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_c772eac795b2a73bb558760c71d88a64d08acf1da8d941d348b2321ec783e645",
+                                                    "typeString": "literal_string \"only swap when skewed\""
+                                                }
+                                            ],
+                                            "id": 1108,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "12100:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 1114,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "12100:52:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 1115,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "12100:52:0"
+                                },
+                                {
+                                    "id": 1116,
+                                    "nodeType": "PlaceholderStatement",
+                                    "src": "12162:1:0"
+                                }
+                            ]
+                        },
+                        "id": 1118,
+                        "name": "onlyWhenSkewed",
+                        "nameLocation": "12073:14:0",
+                        "nodeType": "ModifierDefinition",
+                        "parameters": {
+                            "id": 1107,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "12087:2:0"
+                        },
+                        "src": "12064:106:0",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 1132,
+                            "nodeType": "Block",
+                            "src": "12200:117:0",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "id": 1127,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "expression": {
+                                                                "id": 1123,
+                                                                "name": "msg",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -15,
+                                                                "src": "12238:3:0",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_magic_message",
+                                                                    "typeString": "msg"
+                                                                }
+                                                            },
+                                                            "id": 1124,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "sender",
+                                                            "nodeType": "MemberAccess",
+                                                            "src": "12238:10:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 1121,
+                                                            "name": "skewVault",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 66,
+                                                            "src": "12218:9:0",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                                "typeString": "contract SkewVault"
+                                                            }
+                                                        },
+                                                        "id": 1122,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "whiteList",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 1163,
+                                                        "src": "12218:19:0",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_bool_$",
+                                                            "typeString": "function (address) view external returns (bool)"
+                                                        }
+                                                    },
+                                                    "id": 1125,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "12218:31:0",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "hexValue": "74727565",
+                                                    "id": 1126,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "bool",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "12253:4:0",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    },
+                                                    "value": "true"
+                                                },
+                                                "src": "12218:39:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "4f6e6c792077686974656c6973746564206163636f756e74732063616e2065786563757465",
+                                                "id": 1128,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "12259:39:0",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_1dcc627bb7594180bb530cc12775f52c1eba127262463f14a0c3b16e7fb715ad",
+                                                    "typeString": "literal_string \"Only whitelisted accounts can execute\""
+                                                },
+                                                "value": "Only whitelisted accounts can execute"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_1dcc627bb7594180bb530cc12775f52c1eba127262463f14a0c3b16e7fb715ad",
+                                                    "typeString": "literal_string \"Only whitelisted accounts can execute\""
+                                                }
+                                            ],
+                                            "id": 1120,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "12210:7:0",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 1129,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "12210:89:0",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 1130,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "12210:89:0"
+                                },
+                                {
+                                    "id": 1131,
+                                    "nodeType": "PlaceholderStatement",
+                                    "src": "12309:1:0"
+                                }
+                            ]
+                        },
+                        "id": 1133,
+                        "name": "onlyWhitelist",
+                        "nameLocation": "12184:13:0",
+                        "nodeType": "ModifierDefinition",
+                        "parameters": {
+                            "id": 1119,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "12197:2:0"
+                        },
+                        "src": "12175:142:0",
+                        "virtual": false,
+                        "visibility": "internal"
+                    }
+                ],
+                "scope": 1135,
+                "src": "1078:11241:0",
+                "usedErrors": []
+            }
+        ],
+        "src": "39:12281:0"
+    }
+}
diff --git a/out/SkewVault.sol/SkewVault.json b/out/SkewVault.sol/SkewVault.json
new file mode 100644
index 0000000..ca26ed1
--- /dev/null
+++ b/out/SkewVault.sol/SkewVault.json
@@ -0,0 +1,3183 @@
+{
+    "abi": [
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "_underlying",
+                    "type": "address"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "constructor"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "owner",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "spender",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "amount",
+                    "type": "uint256"
+                }
+            ],
+            "name": "Approval",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "caller",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "owner",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "assets",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "shares",
+                    "type": "uint256"
+                }
+            ],
+            "name": "Deposit",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "previousOwner",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "newOwner",
+                    "type": "address"
+                }
+            ],
+            "name": "OwnershipTransferred",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "from",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "to",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "amount",
+                    "type": "uint256"
+                }
+            ],
+            "name": "Transfer",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "caller",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "receiver",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "internalType": "address",
+                    "name": "owner",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "assets",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "shares",
+                    "type": "uint256"
+                }
+            ],
+            "name": "Withdraw",
+            "type": "event"
+        },
+        {
+            "inputs": [],
+            "name": "DOMAIN_SEPARATOR",
+            "outputs": [
+                {
+                    "internalType": "bytes32",
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "allowance",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "spender",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "amount",
+                    "type": "uint256"
+                }
+            ],
+            "name": "approve",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "asset",
+            "outputs": [
+                {
+                    "internalType": "contract ERC20",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "balanceOf",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "shares",
+                    "type": "uint256"
+                }
+            ],
+            "name": "convertToAssets",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "assets",
+                    "type": "uint256"
+                }
+            ],
+            "name": "convertToShares",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "decimals",
+            "outputs": [
+                {
+                    "internalType": "uint8",
+                    "name": "",
+                    "type": "uint8"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "assets",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "address",
+                    "name": "receiver",
+                    "type": "address"
+                }
+            ],
+            "name": "deposit",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "shares",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "maxDeposit",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "maxMint",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "owner",
+                    "type": "address"
+                }
+            ],
+            "name": "maxRedeem",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "owner",
+                    "type": "address"
+                }
+            ],
+            "name": "maxWithdraw",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "shares",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "address",
+                    "name": "receiver",
+                    "type": "address"
+                }
+            ],
+            "name": "mint",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "assets",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "name",
+            "outputs": [
+                {
+                    "internalType": "string",
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "nonces",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "owner",
+            "outputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "owner",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "spender",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "value",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "deadline",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "uint8",
+                    "name": "v",
+                    "type": "uint8"
+                },
+                {
+                    "internalType": "bytes32",
+                    "name": "r",
+                    "type": "bytes32"
+                },
+                {
+                    "internalType": "bytes32",
+                    "name": "s",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "permit",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "assets",
+                    "type": "uint256"
+                }
+            ],
+            "name": "previewDeposit",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "shares",
+                    "type": "uint256"
+                }
+            ],
+            "name": "previewMint",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "shares",
+                    "type": "uint256"
+                }
+            ],
+            "name": "previewRedeem",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "assets",
+                    "type": "uint256"
+                }
+            ],
+            "name": "previewWithdraw",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "shares",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "address",
+                    "name": "receiver",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "owner",
+                    "type": "address"
+                }
+            ],
+            "name": "redeem",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "assets",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "renounceOwnership",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "_longFarmer",
+                    "type": "address"
+                }
+            ],
+            "name": "setLongFarmer",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "_addr",
+                    "type": "address"
+                },
+                {
+                    "internalType": "bool",
+                    "name": "status",
+                    "type": "bool"
+                }
+            ],
+            "name": "setWhiteList",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "symbol",
+            "outputs": [
+                {
+                    "internalType": "string",
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "totalAssets",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "totalSupply",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "to",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "amount",
+                    "type": "uint256"
+                }
+            ],
+            "name": "transfer",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "from",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "to",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "amount",
+                    "type": "uint256"
+                }
+            ],
+            "name": "transferFrom",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "newOwner",
+                    "type": "address"
+                }
+            ],
+            "name": "transferOwnership",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "underlying",
+            "outputs": [
+                {
+                    "internalType": "contract ERC20",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "whiteList",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "assets",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "address",
+                    "name": "receiver",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "owner",
+                    "type": "address"
+                }
+            ],
+            "name": "withdraw",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "shares",
+                    "type": "uint256"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        }
+    ],
+    "bytecode": {
+        "object": "0x6101206040523480156200001257600080fd5b5060405162001f1e38038062001f1e8339810160408190526200003591620002e8565b806040518060400160405280600b81526020016a151c9858d95c95985d5b1d60aa1b815250604051806040016040528060048152602001631515931560e21b8152508181846001600160a01b031663313ce5676040518163ffffffff1660e01b8152600401602060405180830381865afa158015620000b8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620000de91906200031a565b8251620000f390600090602086019062000242565b5081516200010990600190602085019062000242565b5060ff81166080524660a0526200011f62000154565b60c052505050506001600160a01b039190911660e052506200014133620001f0565b6001600160a01b03166101005262000420565b60007f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f60006040516200018891906200037c565b6040805191829003822060208301939093528101919091527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc660608201524660808201523060a082015260c00160405160208183030381529060405280519060200120905090565b600680546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b82805462000250906200033f565b90600052602060002090601f016020900481019282620002745760008555620002bf565b82601f106200028f57805160ff1916838001178555620002bf565b82800160010185558215620002bf579182015b82811115620002bf578251825591602001919060010190620002a2565b50620002cd929150620002d1565b5090565b5b80821115620002cd5760008155600101620002d2565b600060208284031215620002fb57600080fd5b81516001600160a01b03811681146200031357600080fd5b9392505050565b6000602082840312156200032d57600080fd5b815160ff811681146200031357600080fd5b600181811c908216806200035457607f821691505b602082108114156200037657634e487b7160e01b600052602260045260246000fd5b50919050565b600080835481600182811c9150808316806200039957607f831692505b6020808410821415620003ba57634e487b7160e01b86526022600452602486fd5b818015620003d15760018114620003e35762000412565b60ff1986168952848901965062000412565b60008a81526020902060005b868110156200040a5781548b820152908501908301620003ef565b505084890196505b509498975050505050505050565b60805160a05160c05160e05161010051611a8f6200048f600039600081816103a3015281816105e8015261095e01526000818161031401528181610acc01528181610bf301528181610dee0152610f37015260006108c501526000610890015260006102b00152611a8f6000f3fe608060405234801561001057600080fd5b50600436106102115760003560e01c8063715018a611610125578063ba087652116100ad578063d505accf1161007c578063d505accf146104be578063d905777e146104d1578063dd62ed3e146104fa578063ef8b30f714610525578063f2fde38b1461053857600080fd5b8063ba08765214610485578063c63d75b614610363578063c6e6f59214610498578063ce96cb77146104ab57600080fd5b806394bf804d116100f457806394bf804d1461043157806395d89b4114610444578063a9059cbb1461044c578063b3d7f6b91461045f578063b460af941461047257600080fd5b8063715018a6146103e55780637ecebe00146103ed5780638d14e1271461040d5780638da5cb5b1461042057600080fd5b80633644e515116101a8578063402d267d11610177578063402d267d146103635780634cdad506146103785780636e553f651461038b5780636f307dc31461039e57806370a08231146103c557600080fd5b80633644e515146102e4578063372c12b1146102ec57806338d52e0f1461030f578063400a80ec1461034e57600080fd5b80630a28a477116101e45780630a28a4771461027c57806318160ddd1461028f57806323b872dd14610298578063313ce567146102ab57600080fd5b806301e1d1141461021657806306fdde031461023157806307a2d13a14610246578063095ea7b314610259575b600080fd5b61021e61054b565b6040519081526020015b60405180910390f35b610239610666565b604051610228919061165d565b61021e6102543660046116b2565b6106f4565b61026c6102673660046116e7565b61071f565b6040519015158152602001610228565b61021e61028a3660046116b2565b61078c565b61021e60025481565b61026c6102a6366004611711565b6107ac565b6102d27f000000000000000000000000000000000000000000000000000000000000000081565b60405160ff9091168152602001610228565b61021e61088c565b61026c6102fa36600461174d565b60086020526000908152604090205460ff1681565b6103367f000000000000000000000000000000000000000000000000000000000000000081565b6040516001600160a01b039091168152602001610228565b61036161035c36600461174d565b6108e7565b005b61021e61037136600461174d565b5060001990565b61021e6103863660046116b2565b610a6c565b61021e610399366004611768565b610a77565b6103367f000000000000000000000000000000000000000000000000000000000000000081565b61021e6103d336600461174d565b60036020526000908152604090205481565b610361610b4e565b61021e6103fb36600461174d565b60056020526000908152604090205481565b61036161041b3660046117a2565b610b84565b6006546001600160a01b0316610336565b61021e61043f366004611768565b610bd9565b610239610c75565b61026c61045a3660046116e7565b610c82565b61021e61046d3660046116b2565b610ce8565b61021e6104803660046117d9565b610d07565b61021e6104933660046117d9565b610e15565b61021e6104a63660046116b2565b610f5e565b61021e6104b936600461174d565b610f7e565b6103616104cc366004611815565b610fa0565b61021e6104df36600461174d565b6001600160a01b031660009081526003602052604090205490565b61021e610508366004611888565b600460209081526000928352604080842090915290825290205481565b61021e6105333660046116b2565b6111e4565b61036161054636600461174d565b6111ef565b600080600760009054906101000a90046001600160a01b03166001600160a01b0316633fa4f2456040518163ffffffff1660e01b8152600401602060405180830381865afa1580156105a1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906105c591906118b2565b6040516370a0823160e01b81523060048201529091506000906001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016906370a0823190602401602060405180830381865afa15801561062f573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061065391906118b2565b905061065f81836118e1565b9392505050565b60008054610673906118f9565b80601f016020809104026020016040519081016040528092919081815260200182805461069f906118f9565b80156106ec5780601f106106c1576101008083540402835291602001916106ec565b820191906000526020600020905b8154815290600101906020018083116106cf57829003601f168201915b505050505081565b60025460009080156107185761071361070b61054b565b84908361128a565b61065f565b5090919050565b3360008181526004602090815260408083206001600160a01b038716808552925280832085905551919290917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259061077a9086815260200190565b60405180910390a35060015b92915050565b600254600090801561071857610713816107a461054b565b8591906112a9565b6001600160a01b03831660009081526004602090815260408083203384529091528120546000198114610808576107e38382611934565b6001600160a01b03861660009081526004602090815260408083203384529091529020555b6001600160a01b03851660009081526003602052604081208054859290610830908490611934565b90915550506001600160a01b0380851660008181526003602052604090819020805487019055519091871690600080516020611a3a833981519152906108799087815260200190565b60405180910390a3506001949350505050565b60007f000000000000000000000000000000000000000000000000000000000000000046146108c2576108bd6112d7565b905090565b507f000000000000000000000000000000000000000000000000000000000000000090565b6006546001600160a01b0316331461091a5760405162461bcd60e51b81526004016109119061194b565b60405180910390fd5b600780546001600160a01b0319166001600160a01b0383811691821790925560405163095ea7b360e01b81526004810191909152670de0b6b3a764000060248201527f00000000000000000000000000000000000000000000000000000000000000009091169063095ea7b3906044016020604051808303816000875af11580156109a9573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109cd9190611980565b50600754604051636eb1769f60e11b815273c3d2052479dbc010480ae16204777c1469ceffc960048201526001600160a01b039091166024820152739e062eee2c0ab96e1e1c8ce38bf14ba3fa0a35f69063dd62ed3e90604401602060405180830381865afa158015610a44573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a6891906118b2565b5050565b6000610786826106f4565b6000610a82836111e4565b905080610abf5760405162461bcd60e51b815260206004820152600b60248201526a5a45524f5f53484152455360a81b6044820152606401610911565b610af46001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016333086611371565b610afe82826113fb565b60408051848152602081018390526001600160a01b0384169133917fdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7910160405180910390a36107868382611455565b6006546001600160a01b03163314610b785760405162461bcd60e51b81526004016109119061194b565b610b8260006114d9565b565b6006546001600160a01b03163314610bae5760405162461bcd60e51b81526004016109119061194b565b6001600160a01b03919091166000908152600860205260409020805460ff1916911515919091179055565b6000610be483610ce8565b9050610c1b6001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016333084611371565b610c2582846113fb565b60408051828152602081018590526001600160a01b0384169133917fdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7910160405180910390a36107868184611455565b60018054610673906118f9565b33600090815260036020526040812080548391908390610ca3908490611934565b90915550506001600160a01b03831660008181526003602052604090819020805485019055513390600080516020611a3a8339815191529061077a9086815260200190565b600254600090801561071857610713610cff61054b565b8490836112a9565b6000610d128461078c565b9050336001600160a01b03831614610d82576001600160a01b03821660009081526004602090815260408083203384529091529020546000198114610d8057610d5b8282611934565b6001600160a01b03841660009081526004602090815260408083203384529091529020555b505b610d8c848261152b565b610d96828261157d565b60408051858152602081018390526001600160a01b03808516929086169133917ffbde797d201c681b91056529119e0b02407c7bb96a4a2c75c01fc9667232c8db910160405180910390a461065f6001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001684866115df565b6000336001600160a01b03831614610e85576001600160a01b03821660009081526004602090815260408083203384529091529020546000198114610e8357610e5e8582611934565b6001600160a01b03841660009081526004602090815260408083203384529091529020555b505b610e8e84610a6c565b905080610ecb5760405162461bcd60e51b815260206004820152600b60248201526a5a45524f5f41535345545360a81b6044820152606401610911565b610ed5818561152b565b610edf828561157d565b60408051828152602081018690526001600160a01b03808516929086169133917ffbde797d201c681b91056529119e0b02407c7bb96a4a2c75c01fc9667232c8db910160405180910390a461065f6001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001684836115df565b60025460009080156107185761071381610f7661054b565b85919061128a565b6001600160a01b038116600090815260036020526040812054610786906106f4565b42841015610ff05760405162461bcd60e51b815260206004820152601760248201527f5045524d49545f444541444c494e455f455850495245440000000000000000006044820152606401610911565b60006001610ffc61088c565b6001600160a01b038a811660008181526005602090815260409182902080546001810190915582517f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c98184015280840194909452938d166060840152608083018c905260a083019390935260c08083018b90528151808403909101815260e08301909152805192019190912061190160f01b6101008301526101028201929092526101228101919091526101420160408051601f198184030181528282528051602091820120600084529083018083525260ff871690820152606081018590526080810184905260a0016020604051602081039080840390855afa158015611108573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b0381161580159061113e5750876001600160a01b0316816001600160a01b0316145b61117b5760405162461bcd60e51b815260206004820152600e60248201526d24a72b20a624a22fa9a4a3a722a960911b6044820152606401610911565b6001600160a01b0390811660009081526004602090815260408083208a8516808552908352928190208990555188815291928a16917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a350505050505050565b600061078682610f5e565b6006546001600160a01b031633146112195760405162461bcd60e51b81526004016109119061194b565b6001600160a01b03811661127e5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610911565b611287816114d9565b50565b8282028115158415858304851417166112a257600080fd5b0492915050565b8282028115158415858304851417166112c157600080fd5b6001826001830304018115150290509392505050565b60007f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f6000604051611309919061199d565b6040805191829003822060208301939093528101919091527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc660608201524660808201523060a082015260c00160405160208183030381529060405280519060200120905090565b60006040516323b872dd60e01b81528460048201528360248201528260448201526020600060648360008a5af13d15601f3d11600160005114161716915050806113f45760405162461bcd60e51b81526020600482015260146024820152731514905394d1915497d19493d357d1905253115160621b6044820152606401610911565b5050505050565b806002600082825461140d91906118e1565b90915550506001600160a01b038216600081815260036020908152604080832080548601905551848152600080516020611a3a83398151915291015b60405180910390a35050565b3360009081526008602052604090205460ff16151560011461147657600080fd5b600754604051630fcdb7bb60e21b8152600481018490526001600160a01b0390911690633f36deec906024015b600060405180830381600087803b1580156114bd57600080fd5b505af11580156114d1573d6000803e3d6000fd5b505050505050565b600680546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b3360009081526008602052604090205460ff16151560011461154c57600080fd5b6007546040516322baaeeb60e11b8152600481018490526001600160a01b03909116906345755dd6906024016114a3565b6001600160a01b038216600090815260036020526040812080548392906115a5908490611934565b90915550506002805482900390556040518181526000906001600160a01b03841690600080516020611a3a83398151915290602001611449565b600060405163a9059cbb60e01b8152836004820152826024820152602060006044836000895af13d15601f3d11600160005114161716915050806116575760405162461bcd60e51b815260206004820152600f60248201526e1514905394d1915497d19052531151608a1b6044820152606401610911565b50505050565b600060208083528351808285015260005b8181101561168a5785810183015185820160400152820161166e565b8181111561169c576000604083870101525b50601f01601f1916929092016040019392505050565b6000602082840312156116c457600080fd5b5035919050565b80356001600160a01b03811681146116e257600080fd5b919050565b600080604083850312156116fa57600080fd5b611703836116cb565b946020939093013593505050565b60008060006060848603121561172657600080fd5b61172f846116cb565b925061173d602085016116cb565b9150604084013590509250925092565b60006020828403121561175f57600080fd5b61065f826116cb565b6000806040838503121561177b57600080fd5b8235915061178b602084016116cb565b90509250929050565b801515811461128757600080fd5b600080604083850312156117b557600080fd5b6117be836116cb565b915060208301356117ce81611794565b809150509250929050565b6000806000606084860312156117ee57600080fd5b833592506117fe602085016116cb565b915061180c604085016116cb565b90509250925092565b600080600080600080600060e0888a03121561183057600080fd5b611839886116cb565b9650611847602089016116cb565b95506040880135945060608801359350608088013560ff8116811461186b57600080fd5b9699959850939692959460a0840135945060c09093013592915050565b6000806040838503121561189b57600080fd5b6118a4836116cb565b915061178b602084016116cb565b6000602082840312156118c457600080fd5b5051919050565b634e487b7160e01b600052601160045260246000fd5b600082198211156118f4576118f46118cb565b500190565b600181811c9082168061190d57607f821691505b6020821081141561192e57634e487b7160e01b600052602260045260246000fd5b50919050565b600082821015611946576119466118cb565b500390565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60006020828403121561199257600080fd5b815161065f81611794565b600080835481600182811c9150808316806119b957607f831692505b60208084108214156119d957634e487b7160e01b86526022600452602486fd5b8180156119ed57600181146119fe57611a2b565b60ff19861689528489019650611a2b565b60008a81526020902060005b86811015611a235781548b820152908501908301611a0a565b505084890196505b50949897505050505050505056feddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3efa264697066735822122062631b3d1db64c106725473c22b67024f528f12022d008c0f96a884e1872955364736f6c634300080a0033",
+        "sourceMap": "571:1766:1:-:0;;;815:279;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;876:11;1181:172:15;;;;;;;;;;;;;-1:-1:-1;;;1181:172:15;;;;;;;;;;;;;;;;-1:-1:-1;;;1181:172:15;;;1287:5;1294:7;1303:6;-1:-1:-1;;;;;1303:15:15;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2091:12:16;;;;:4;;:12;;;;;:::i;:::-;-1:-1:-1;2113:16:16;;;;:6;;:16;;;;;:::i;:::-;-1:-1:-1;2139:20:16;;;;;2189:13;2170:32;;2239:24;:22;:24::i;:::-;2212:51;;-1:-1:-1;;;;;;;;;1332:14:15;;;::::1;;::::0;-1:-1:-1;921:32:6;719:10:12;921:18:6;:32::i;:::-;-1:-1:-1;;;;;923:31:1::1;;::::0;571:1766;;5507:446:16;5572:7;5669:95;5802:4;5786:22;;;;;;:::i;:::-;;;;;;;;;;5637:295;;;2469:25:23;;;;2510:18;;2503:34;;;;5830:14:16;2553:18:23;;;2546:34;5866:13:16;2596:18:23;;;2589:34;5909:4:16;2639:19:23;;;2632:61;2441:19;;5637:295:16;;;;;;;;;;;;5610:336;;;;;;5591:355;;5507:446;:::o;2270:187:6:-;2362:6;;;-1:-1:-1;;;;;2378:17:6;;;-1:-1:-1;;;;;;2378:17:6;;;;;;;2410:40;;2362:6;;;2378:17;2362:6;;2410:40;;2343:16;;2410:40;2333:124;2270:187;:::o;571:1766:1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;571:1766:1;;;-1:-1:-1;571:1766:1;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:290:23;84:6;137:2;125:9;116:7;112:23;108:32;105:52;;;153:1;150;143:12;105:52;179:16;;-1:-1:-1;;;;;224:31:23;;214:42;;204:70;;270:1;267;260:12;204:70;293:5;14:290;-1:-1:-1;;;14:290:23:o;309:273::-;377:6;430:2;418:9;409:7;405:23;401:32;398:52;;;446:1;443;436:12;398:52;478:9;472:16;528:4;521:5;517:16;510:5;507:27;497:55;;548:1;545;538:12;587:380;666:1;662:12;;;;709;;;730:61;;784:4;776:6;772:17;762:27;;730:61;837:2;829:6;826:14;806:18;803:38;800:161;;;883:10;878:3;874:20;871:1;864:31;918:4;915:1;908:15;946:4;943:1;936:15;800:161;;587:380;;;:::o;1101:1104::-;1231:3;1260:1;1293:6;1287:13;1323:3;1345:1;1373:9;1369:2;1365:18;1355:28;;1433:2;1422:9;1418:18;1455;1445:61;;1499:4;1491:6;1487:17;1477:27;;1445:61;1525:2;1573;1565:6;1562:14;1542:18;1539:38;1536:165;;;-1:-1:-1;;;1600:33:23;;1656:4;1653:1;1646:15;1686:4;1607:3;1674:17;1536:165;1717:18;1744:104;;;;1862:1;1857:323;;;;1710:470;;1744:104;-1:-1:-1;;1777:24:23;;1765:37;;1822:16;;;;-1:-1:-1;1744:104:23;;1857:323;1048:1;1041:14;;;1085:4;1072:18;;1955:1;1969:165;1983:6;1980:1;1977:13;1969:165;;;2061:14;;2048:11;;;2041:35;2104:16;;;;1998:10;;1969:165;;;1973:3;;2163:6;2158:3;2154:16;2147:23;;1710:470;-1:-1:-1;2196:3:23;;1101:1104;-1:-1:-1;;;;;;;;1101:1104:23:o;2210:489::-;571:1766:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
+        "linkReferences": {}
+    },
+    "deployedBytecode": {
+        "object": "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",
+        "sourceMap": "571:1766:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1100:208;;;:::i;:::-;;;160:25:23;;;148:2;133:18;1100:208:1;;;;;;;;1028:18:16;;;:::i;:::-;;;;;;;:::i;4460:257:15:-;;;;;;:::i;:::-;;:::i;2458:211:16:-;;;;;;:::i;:::-;;:::i;:::-;;;1585:14:23;;1578:22;1560:41;;1548:2;1533:18;2458:211:16;1420:187:23;5111:255:15;;;;;;:::i;:::-;;:::i;1301:26:16:-;;;;;;3054:592;;;;;;:::i;:::-;;:::i;1080:31::-;;;;;;;;2117:4:23;2105:17;;;2087:36;;2075:2;2060:18;1080:31:16;1945:184:23;5324:177:16;;;:::i;767:41:1:-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;1146:28:15;;;;;;;;-1:-1:-1;;;;;2685:32:23;;;2667:51;;2655:2;2640:18;1146:28:15;2507:217:23;1431:346:1;;;;;;:::i;:::-;;:::i;:::-;;5693:108:15;;;;;;:::i;:::-;-1:-1:-1;;;5777:17:15;5693:108;5372:124;;;;;;:::i;:::-;;:::i;1547:516::-;;;;;;:::i;:::-;;:::i;727:33:1:-;;;;;1334:44:16;;;;;;:::i;:::-;;;;;;;;;;;;;;1668:101:6;;;:::i;1748:41:16:-;;;;;;:::i;:::-;;;;;;;;;;;;;;1314:111:1;;;;;;:::i;:::-;;:::i;1036:85:6:-;1108:6;;-1:-1:-1;;;;;1108:6:6;1036:85;;2069:467:15;;;;;;:::i;:::-;;:::i;1053:20:16:-;;;:::i;2675:373::-;;;;;;:::i;:::-;;:::i;4854:251:15:-;;;;;;:::i;:::-;;:::i;2542:679::-;;;;;;:::i;:::-;;:::i;3227:713::-;;;;;;:::i;:::-;;:::i;4197:257::-;;;;;;:::i;:::-;;:::i;5918:131::-;;;;;;:::i;:::-;;:::i;3835:1483:16:-;;;;;;:::i;:::-;;:::i;6055:112:15:-;;;;;;:::i;:::-;-1:-1:-1;;;;;6144:16:15;6118:7;6144:16;;;:9;:16;;;;;;;6055:112;1385:64:16;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;4723:125:15;;;;;;:::i;:::-;;:::i;1918:198:6:-;;;;;;:::i;:::-;;:::i;1100:208:1:-;1153:7;1172:11;1186:10;;;;;;;;;-1:-1:-1;;;;;1186:10:1;-1:-1:-1;;;;;1186:16:1;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1227:35;;-1:-1:-1;;;1227:35:1;;1256:4;1227:35;;;2667:51:23;1172:32:1;;-1:-1:-1;1214:10:1;;-1:-1:-1;;;;;1227:10:1;:20;;;;2640:18:23;;1227:35:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1214:48;-1:-1:-1;1272:9:1;1214:48;1272:9;;:::i;:::-;;1100:208;-1:-1:-1;;;1100:208:1:o;1028:18:16:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;4460:257:15:-;4566:11;;4530:7;;4647:11;;:63;;4670:40;4688:13;:11;:13::i;:::-;4670:6;;4703;4670:17;:40::i;:::-;4647:63;;;-1:-1:-1;4661:6:15;;4640:70;-1:-1:-1;4460:257:15:o;2458:211:16:-;2558:10;2532:4;2548:21;;;:9;:21;;;;;;;;-1:-1:-1;;;;;2548:30:16;;;;;;;;;;:39;;;2603:37;2532:4;;2548:30;;2603:37;;;;2581:6;160:25:23;;148:2;133:18;;14:177;2603:37:16;;;;;;;;-1:-1:-1;2658:4:16;2458:211;;;;;:::o;5111:255:15:-;5217:11;;5181:7;;5298:11;;:61;;5321:38;5337:6;5345:13;:11;:13::i;:::-;5321:6;;:38;:15;:38::i;3054:592:16:-;-1:-1:-1;;;;;3206:15:16;;3172:4;3206:15;;;:9;:15;;;;;;;;3222:10;3206:27;;;;;;;;-1:-1:-1;;3284:28:16;;3280:80;;3344:16;3354:6;3344:7;:16;:::i;:::-;-1:-1:-1;;;;;3314:15:16;;;;;;:9;:15;;;;;;;;3330:10;3314:27;;;;;;;:46;3280:80;-1:-1:-1;;;;;3371:15:16;;;;;;:9;:15;;;;;:25;;3390:6;;3371:15;:25;;3390:6;;3371:25;:::i;:::-;;;;-1:-1:-1;;;;;;;3542:13:16;;;;;;;:9;:13;;;;;;;:23;;;;;;3591:26;3542:13;;3591:26;;;-1:-1:-1;;;;;;;;;;;3591:26:16;;;3559:6;160:25:23;;148:2;133:18;;14:177;3591:26:16;;;;;;;;-1:-1:-1;3635:4:16;;3054:592;-1:-1:-1;;;;3054:592:16:o;5324:177::-;5381:7;5424:16;5407:13;:33;:87;;5470:24;:22;:24::i;:::-;5400:94;;5324:177;:::o;5407:87::-;-1:-1:-1;5443:24:16;;5324:177::o;1431:346:1:-;1108:6:6;;-1:-1:-1;;;;;1108:6:6;719:10:12;1248:23:6;1240:68;;;;-1:-1:-1;;;1240:68:6;;;;;;;:::i;:::-;;;;;;;;;1502:10:1::1;:36:::0;;-1:-1:-1;;;;;;1502:36:1::1;-1:-1:-1::0;;;;;1502:36:1;;::::1;::::0;;::::1;::::0;;;1548:45:::1;::::0;-1:-1:-1;;;1548:45:1;;::::1;::::0;::::1;6465:51:23::0;;;;1588:4:1::1;6532:18:23::0;;;6525:34;1548:10:1::1;:18:::0;;::::1;::::0;::::1;::::0;6438::23;;1548:45:1::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;1749:10:1::1;::::0;1603:167:::1;::::0;-1:-1:-1;;;1603:167:1;;1684:42:::1;1603:167;::::0;::::1;7032:34:23::0;-1:-1:-1;;;;;1749:10:1;;::::1;7082:18:23::0;;;7075:43;1609:42:1::1;::::0;1603:59:::1;::::0;6967:18:23;;1603:167:1::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;1431:346:::0;:::o;5372:124:15:-;5440:7;5466:23;5482:6;5466:15;:23::i;1547:516::-;1622:14;1741:22;1756:6;1741:14;:22::i;:::-;1732:31;-1:-1:-1;1731:38:15;1723:62;;;;-1:-1:-1;;;1723:62:15;;7331:2:23;1723:62:15;;;7313:21:23;7370:2;7350:18;;;7343:30;-1:-1:-1;;;7389:18:23;;;7382:41;7440:18;;1723:62:15;7129:335:23;1723:62:15;1865:57;-1:-1:-1;;;;;1865:5:15;:22;1888:10;1908:4;1915:6;1865:22;:57::i;:::-;1933:23;1939:8;1949:6;1933:5;:23::i;:::-;1972:45;;;7643:25:23;;;7699:2;7684:18;;7677:34;;;-1:-1:-1;;;;;1972:45:15;;;1980:10;;1972:45;;7616:18:23;1972:45:15;;;;;;;2028:28;2041:6;2049;2028:12;:28::i;1668:101:6:-;1108:6;;-1:-1:-1;;;;;1108:6:6;719:10:12;1248:23:6;1240:68;;;;-1:-1:-1;;;1240:68:6;;;;;;;:::i;:::-;1732:30:::1;1759:1;1732:18;:30::i;:::-;1668:101::o:0;1314:111:1:-;1108:6:6;;-1:-1:-1;;;;;1108:6:6;719:10:12;1248:23:6;1240:68;;;;-1:-1:-1;;;1240:68:6;;;;;;;:::i;:::-;-1:-1:-1;;;;;1393:16:1;;;::::1;;::::0;;;:9:::1;:16;::::0;;;;:25;;-1:-1:-1;;1393:25:1::1;::::0;::::1;;::::0;;;::::1;::::0;;1314:111::o;2069:467:15:-;2141:14;2176:19;2188:6;2176:11;:19::i;:::-;2167:28;-1:-1:-1;2338:57:15;-1:-1:-1;;;;;2338:5:15;:22;2361:10;2381:4;2167:28;2338:22;:57::i;:::-;2406:23;2412:8;2422:6;2406:5;:23::i;:::-;2445:45;;;7643:25:23;;;7699:2;7684:18;;7677:34;;;-1:-1:-1;;;;;2445:45:15;;;2453:10;;2445:45;;7616:18:23;2445:45:15;;;;;;;2501:28;2514:6;2522;2501:12;:28::i;1053:20:16:-;;;;;;;:::i;2675:373::-;2771:10;2745:4;2761:21;;;:9;:21;;;;;:31;;2786:6;;2761:21;2745:4;;2761:31;;2786:6;;2761:31;:::i;:::-;;;;-1:-1:-1;;;;;;;2938:13:16;;;;;;:9;:13;;;;;;;:23;;;;;;2987:32;2996:10;;-1:-1:-1;;;;;;;;;;;2987:32:16;;;2955:6;160:25:23;;148:2;133:18;;14:177;4854:251:15;4956:11;;4920:7;;5037:11;;:61;;5060:38;5076:13;:11;:13::i;:::-;5060:6;;5091;5060:15;:38::i;2542:679::-;2663:14;2698:23;2714:6;2698:15;:23::i;:::-;2689:32;-1:-1:-1;2803:10:15;-1:-1:-1;;;;;2803:19:15;;;2799:228;;-1:-1:-1;;;;;2856:16:15;;2838:15;2856:16;;;:9;:16;;;;;;;;2873:10;2856:28;;;;;;;;-1:-1:-1;;2939:28:15;;2935:81;;3000:16;3010:6;3000:7;:16;:::i;:::-;-1:-1:-1;;;;;2969:16:15;;;;;;:9;:16;;;;;;;;2986:10;2969:28;;;;;;;:47;2935:81;2824:203;2799:228;3037:30;3052:6;3060;3037:14;:30::i;:::-;3078:20;3084:5;3091:6;3078:5;:20::i;:::-;3114:53;;;7643:25:23;;;7699:2;7684:18;;7677:34;;;-1:-1:-1;;;;;3114:53:15;;;;;;;;3123:10;;3114:53;;7616:18:23;3114:53:15;;;;;;;3178:36;-1:-1:-1;;;;;3178:5:15;:18;3197:8;3207:6;3178:18;:36::i;3227:713::-;3346:14;3376:10;-1:-1:-1;;;;;3376:19:15;;;3372:228;;-1:-1:-1;;;;;3429:16:15;;3411:15;3429:16;;;:9;:16;;;;;;;;3446:10;3429:28;;;;;;;;-1:-1:-1;;3512:28:15;;3508:81;;3573:16;3583:6;3573:7;:16;:::i;:::-;-1:-1:-1;;;;;3542:16:15;;;;;;:9;:16;;;;;;;;3559:10;3542:28;;;;;;;:47;3508:81;3397:203;3372:228;3702:21;3716:6;3702:13;:21::i;:::-;3693:30;-1:-1:-1;3692:37:15;3684:61;;;;-1:-1:-1;;;3684:61:15;;7924:2:23;3684:61:15;;;7906:21:23;7963:2;7943:18;;;7936:30;-1:-1:-1;;;7982:18:23;;;7975:41;8033:18;;3684:61:15;7722:335:23;3684:61:15;3756:30;3771:6;3779;3756:14;:30::i;:::-;3797:20;3803:5;3810:6;3797:5;:20::i;:::-;3833:53;;;7643:25:23;;;7699:2;7684:18;;7677:34;;;-1:-1:-1;;;;;3833:53:15;;;;;;;;3842:10;;3833:53;;7616:18:23;3833:53:15;;;;;;;3897:36;-1:-1:-1;;;;;3897:5:15;:18;3916:8;3926:6;3897:18;:36::i;4197:257::-;4303:11;;4267:7;;4384:11;;:63;;4407:40;4425:6;4433:13;:11;:13::i;:::-;4407:6;;:40;:17;:40::i;5918:131::-;-1:-1:-1;;;;;6025:16:15;;5983:7;6025:16;;;:9;:16;;;;;;6009:33;;:15;:33::i;3835:1483:16:-;4054:15;4042:8;:27;;4034:63;;;;-1:-1:-1;;;4034:63:16;;8264:2:23;4034:63:16;;;8246:21:23;8303:2;8283:18;;;8276:30;8342:25;8322:18;;;8315:53;8385:18;;4034:63:16;8062:347:23;4034:63:16;4262:24;4289:805;4425:18;:16;:18::i;:::-;-1:-1:-1;;;;;4870:13:16;;;;;;;:6;:13;;;;;;;;;:15;;;;;;;;4508:449;;4552:165;4508:449;;;8701:25:23;8780:18;;;8773:43;;;;8852:15;;;8832:18;;;8825:43;8884:18;;;8877:34;;;8927:19;;;8920:35;;;;8971:19;;;;8964:35;;;4508:449:16;;;;;;;;;;8673:19:23;;;4508:449:16;;;4469:514;;;;;;;;-1:-1:-1;;;4347:658:16;;;9268:27:23;9311:11;;;9304:27;;;;9347:12;;;9340:28;;;;9384:12;;4347:658:16;;;-1:-1:-1;;4347:658:16;;;;;;;;;4316:707;;4347:658;4316:707;;;;4289:805;;;;;;;;;9634:25:23;9707:4;9695:17;;9675:18;;;9668:45;9729:18;;;9722:34;;;9772:18;;;9765:34;;;9606:19;;4289:805:16;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4289:805:16;;-1:-1:-1;;4289:805:16;;;-1:-1:-1;;;;;;;5117:30:16;;;;;;:59;;;5171:5;-1:-1:-1;;;;;5151:25:16;:16;-1:-1:-1;;;;;5151:25:16;;5117:59;5109:86;;;;-1:-1:-1;;;5109:86:16;;10012:2:23;5109:86:16;;;9994:21:23;10051:2;10031:18;;;10024:30;-1:-1:-1;;;10070:18:23;;;10063:44;10124:18;;5109:86:16;9810:338:23;5109:86:16;-1:-1:-1;;;;;5210:27:16;;;;;;;:9;:27;;;;;;;;:36;;;;;;;;;;;;;:44;;;5280:31;160:25:23;;;5210:36:16;;5280:31;;;;;133:18:23;5280:31:16;;;;;;;3835:1483;;;;;;;:::o;4723:125:15:-;4792:7;4818:23;4834:6;4818:15;:23::i;1918:198:6:-;1108:6;;-1:-1:-1;;;;;1108:6:6;719:10:12;1248:23:6;1240:68;;;;-1:-1:-1;;;1240:68:6;;;;;;;:::i;:::-;-1:-1:-1;;;;;2006:22:6;::::1;1998:73;;;::::0;-1:-1:-1;;;1998:73:6;;10355:2:23;1998:73:6::1;::::0;::::1;10337:21:23::0;10394:2;10374:18;;;10367:30;10433:34;10413:18;;;10406:62;-1:-1:-1;;;10484:18:23;;;10477:36;10530:19;;1998:73:6::1;10153:402:23::0;1998:73:6::1;2081:28;2100:8;2081:18;:28::i;:::-;1918:198:::0;:::o;1504:535:17:-;1710:9;;;1841:19;;1834:27;1866:9;;1880;;;1877:16;;1863:31;1830:65;1820:121;;1925:1;1922;1915:12;1820:121;2004:19;;1504:535;-1:-1:-1;;1504:535:17:o;2045:752::-;2249:9;;;2380:19;;2373:27;2405:9;;2419;;;2416:16;;2402:31;2369:65;2359:121;;2464:1;2461;2454:12;2359:121;2778:1;2764:11;2760:1;2757;2753:9;2749:27;2745:35;2740:1;2733:9;2726:17;2722:59;2717:64;;2045:752;;;;;:::o;5507:446:16:-;5572:7;5669:95;5802:4;5786:22;;;;;;:::i;:::-;;;;;;;;;;5637:295;;;12057:25:23;;;;12098:18;;12091:34;;;;5830:14:16;12141:18:23;;;12134:34;5866:13:16;12184:18:23;;;12177:34;5909:4:16;12227:19:23;;;12220:61;12029:19;;5637:295:16;;;;;;;;;;;;5610:336;;;;;;5591:355;;5507:446;:::o;1337:1573:18:-;1475:12;1602:4;1596:11;-1:-1:-1;;;1725:17:18;1718:93;1858:4;1854:1;1835:17;1831:25;1824:39;1942:2;1937;1918:17;1914:26;1907:38;2022:6;2017:2;1998:17;1994:26;1987:42;2826:2;2823:1;2818:3;2799:17;2796:1;2789:5;2782;2777:52;2345:16;2338:24;2332:2;2314:16;2311:24;2307:1;2303;2297:8;2294:15;2290:46;2287:76;2087:756;2076:767;;;2871:7;2863:40;;;;-1:-1:-1;;;2863:40:18;;12494:2:23;2863:40:18;;;12476:21:23;12533:2;12513:18;;;12506:30;-1:-1:-1;;;12552:18:23;;;12545:50;12612:18;;2863:40:18;12292:344:23;2863:40:18;1465:1445;1337:1573;;;;:::o;6147:325:16:-;6232:6;6217:11;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;6384:13:16;;;;;;:9;:13;;;;;;;;:23;;;;;;6433:32;160:25:23;;;-1:-1:-1;;;;;;;;;;;6433:32:16;133:18:23;6433:32:16;;;;;;;;6147:325;;:::o;1783:236:1:-;1891:10;1881:21;;;;:9;:21;;;;;;;;:29;;:21;:29;1873:38;;;;;;1986:10;;:26;;-1:-1:-1;;;1986:26:1;;;;;160:25:23;;;-1:-1:-1;;;;;1986:10:1;;;;:18;;133::23;;1986:26:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1783:236;;:::o;2270:187:6:-;2362:6;;;-1:-1:-1;;;;;2378:17:6;;;-1:-1:-1;;;;;;2378:17:6;;;;;;;2410:40;;2362:6;;;2378:17;2362:6;;2410:40;;2343:16;;2410:40;2333:124;2270:187;:::o;2025:177:1:-;2135:10;2125:21;;;;:9;:21;;;;;;;;:29;;:21;:29;2117:38;;;;;;2165:10;;:30;;-1:-1:-1;;;2165:30:1;;;;;160:25:23;;;-1:-1:-1;;;;;2165:10:1;;;;:22;;133:18:23;;2165:30:1;14:177:23;6478:328:16;-1:-1:-1;;;;;6550:15:16;;;;;;:9;:15;;;;;:25;;6569:6;;6550:15;:25;;6569:6;;6550:25;:::i;:::-;;;;-1:-1:-1;;6718:11:16;:21;;;;;;;6765:34;;160:25:23;;;-1:-1:-1;;;;;;;6765:34:16;;;-1:-1:-1;;;;;;;;;;;6765:34:16;148:2:23;133:18;6765:34:16;14:177:23;2916:1456:18;3028:12;3155:4;3149:11;-1:-1:-1;;;3278:17:18;3271:93;3411:2;3407:1;3388:17;3384:25;3377:37;3491:6;3486:2;3467:17;3463:26;3456:42;4293:2;4290:1;4286:2;4267:17;4264:1;4257:5;4250;4245:51;3814:16;3807:24;3801:2;3783:16;3780:24;3776:1;3772;3766:8;3763:15;3759:46;3756:76;3556:754;3545:765;;;4338:7;4330:35;;;;-1:-1:-1;;;4330:35:18;;12843:2:23;4330:35:18;;;12825:21:23;12882:2;12862:18;;;12855:30;-1:-1:-1;;;12901:18:23;;;12894:45;12956:18;;4330:35:18;12641:339:23;4330:35:18;3018:1354;2916:1456;;;:::o;196:597:23:-;308:4;337:2;366;355:9;348:21;398:6;392:13;441:6;436:2;425:9;421:18;414:34;466:1;476:140;490:6;487:1;484:13;476:140;;;585:14;;;581:23;;575:30;551:17;;;570:2;547:26;540:66;505:10;;476:140;;;634:6;631:1;628:13;625:91;;;704:1;699:2;690:6;679:9;675:22;671:31;664:42;625:91;-1:-1:-1;777:2:23;756:15;-1:-1:-1;;752:29:23;737:45;;;;784:2;733:54;;196:597;-1:-1:-1;;;196:597:23:o;798:180::-;857:6;910:2;898:9;889:7;885:23;881:32;878:52;;;926:1;923;916:12;878:52;-1:-1:-1;949:23:23;;798:180;-1:-1:-1;798:180:23:o;983:173::-;1051:20;;-1:-1:-1;;;;;1100:31:23;;1090:42;;1080:70;;1146:1;1143;1136:12;1080:70;983:173;;;:::o;1161:254::-;1229:6;1237;1290:2;1278:9;1269:7;1265:23;1261:32;1258:52;;;1306:1;1303;1296:12;1258:52;1329:29;1348:9;1329:29;:::i;:::-;1319:39;1405:2;1390:18;;;;1377:32;;-1:-1:-1;;;1161:254:23:o;1612:328::-;1689:6;1697;1705;1758:2;1746:9;1737:7;1733:23;1729:32;1726:52;;;1774:1;1771;1764:12;1726:52;1797:29;1816:9;1797:29;:::i;:::-;1787:39;;1845:38;1879:2;1868:9;1864:18;1845:38;:::i;:::-;1835:48;;1930:2;1919:9;1915:18;1902:32;1892:42;;1612:328;;;;;:::o;2316:186::-;2375:6;2428:2;2416:9;2407:7;2403:23;2399:32;2396:52;;;2444:1;2441;2434:12;2396:52;2467:29;2486:9;2467:29;:::i;2729:254::-;2797:6;2805;2858:2;2846:9;2837:7;2833:23;2829:32;2826:52;;;2874:1;2871;2864:12;2826:52;2910:9;2897:23;2887:33;;2939:38;2973:2;2962:9;2958:18;2939:38;:::i;:::-;2929:48;;2729:254;;;;;:::o;2988:118::-;3074:5;3067:13;3060:21;3053:5;3050:32;3040:60;;3096:1;3093;3086:12;3111:315;3176:6;3184;3237:2;3225:9;3216:7;3212:23;3208:32;3205:52;;;3253:1;3250;3243:12;3205:52;3276:29;3295:9;3276:29;:::i;:::-;3266:39;;3355:2;3344:9;3340:18;3327:32;3368:28;3390:5;3368:28;:::i;:::-;3415:5;3405:15;;;3111:315;;;;;:::o;3639:328::-;3716:6;3724;3732;3785:2;3773:9;3764:7;3760:23;3756:32;3753:52;;;3801:1;3798;3791:12;3753:52;3837:9;3824:23;3814:33;;3866:38;3900:2;3889:9;3885:18;3866:38;:::i;:::-;3856:48;;3923:38;3957:2;3946:9;3942:18;3923:38;:::i;:::-;3913:48;;3639:328;;;;;:::o;3972:693::-;4083:6;4091;4099;4107;4115;4123;4131;4184:3;4172:9;4163:7;4159:23;4155:33;4152:53;;;4201:1;4198;4191:12;4152:53;4224:29;4243:9;4224:29;:::i;:::-;4214:39;;4272:38;4306:2;4295:9;4291:18;4272:38;:::i;:::-;4262:48;;4357:2;4346:9;4342:18;4329:32;4319:42;;4408:2;4397:9;4393:18;4380:32;4370:42;;4462:3;4451:9;4447:19;4434:33;4507:4;4500:5;4496:16;4489:5;4486:27;4476:55;;4527:1;4524;4517:12;4476:55;3972:693;;;;-1:-1:-1;3972:693:23;;;;4550:5;4602:3;4587:19;;4574:33;;-1:-1:-1;4654:3:23;4639:19;;;4626:33;;3972:693;-1:-1:-1;;3972:693:23:o;4670:260::-;4738:6;4746;4799:2;4787:9;4778:7;4774:23;4770:32;4767:52;;;4815:1;4812;4805:12;4767:52;4838:29;4857:9;4838:29;:::i;:::-;4828:39;;4886:38;4920:2;4909:9;4905:18;4886:38;:::i;4935:184::-;5005:6;5058:2;5046:9;5037:7;5033:23;5029:32;5026:52;;;5074:1;5071;5064:12;5026:52;-1:-1:-1;5097:16:23;;4935:184;-1:-1:-1;4935:184:23:o;5124:127::-;5185:10;5180:3;5176:20;5173:1;5166:31;5216:4;5213:1;5206:15;5240:4;5237:1;5230:15;5256:128;5296:3;5327:1;5323:6;5320:1;5317:13;5314:39;;;5333:18;;:::i;:::-;-1:-1:-1;5369:9:23;;5256:128::o;5389:380::-;5468:1;5464:12;;;;5511;;;5532:61;;5586:4;5578:6;5574:17;5564:27;;5532:61;5639:2;5631:6;5628:14;5608:18;5605:38;5602:161;;;5685:10;5680:3;5676:20;5673:1;5666:31;5720:4;5717:1;5710:15;5748:4;5745:1;5738:15;5602:161;;5389:380;;;:::o;5774:125::-;5814:4;5842:1;5839;5836:8;5833:34;;;5847:18;;:::i;:::-;-1:-1:-1;5884:9:23;;5774:125::o;5904:356::-;6106:2;6088:21;;;6125:18;;;6118:30;6184:34;6179:2;6164:18;;6157:62;6251:2;6236:18;;5904:356::o;6570:245::-;6637:6;6690:2;6678:9;6669:7;6665:23;6661:32;6658:52;;;6706:1;6703;6696:12;6658:52;6738:9;6732:16;6757:28;6779:5;6757:28;:::i;10689:1104::-;10819:3;10848:1;10881:6;10875:13;10911:3;10933:1;10961:9;10957:2;10953:18;10943:28;;11021:2;11010:9;11006:18;11043;11033:61;;11087:4;11079:6;11075:17;11065:27;;11033:61;11113:2;11161;11153:6;11150:14;11130:18;11127:38;11124:165;;;-1:-1:-1;;;11188:33:23;;11244:4;11241:1;11234:15;11274:4;11195:3;11262:17;11124:165;11305:18;11332:104;;;;11450:1;11445:323;;;;11298:470;;11332:104;-1:-1:-1;;11365:24:23;;11353:37;;11410:16;;;;-1:-1:-1;11332:104:23;;11445:323;10636:1;10629:14;;;10673:4;10660:18;;11543:1;11557:165;11571:6;11568:1;11565:13;11557:165;;;11649:14;;11636:11;;;11629:35;11692:16;;;;11586:10;;11557:165;;;11561:3;;11751:6;11746:3;11742:16;11735:23;;11298:470;-1:-1:-1;11784:3:23;;10689:1104;-1:-1:-1;;;;;;;;10689:1104:23:o",
+        "linkReferences": {},
+        "immutableReferences": {
+            "1159": [
+                {
+                    "start": 931,
+                    "length": 32
+                },
+                {
+                    "start": 1512,
+                    "length": 32
+                },
+                {
+                    "start": 2398,
+                    "length": 32
+                }
+            ],
+            "5807": [
+                {
+                    "start": 788,
+                    "length": 32
+                },
+                {
+                    "start": 2764,
+                    "length": 32
+                },
+                {
+                    "start": 3059,
+                    "length": 32
+                },
+                {
+                    "start": 3566,
+                    "length": 32
+                },
+                {
+                    "start": 3895,
+                    "length": 32
+                }
+            ],
+            "6310": [
+                {
+                    "start": 688,
+                    "length": 32
+                }
+            ],
+            "6324": [
+                {
+                    "start": 2192,
+                    "length": 32
+                }
+            ],
+            "6326": [
+                {
+                    "start": 2245,
+                    "length": 32
+                }
+            ]
+        }
+    },
+    "ast": {
+        "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/contracts/SkewVault.sol",
+        "exportedSymbols": {
+            "ERC20": [6673],
+            "ERC4626": [6285],
+            "LongFarmer": [1134],
+            "Ownable": [3911],
+            "SafeTransferLib": [6885],
+            "SkewVault": [1326]
+        },
+        "id": 1327,
+        "license": "AGPL-3.0-only",
+        "nodeType": "SourceUnit",
+        "nodes": [
+            {
+                "id": 1136,
+                "literals": ["solidity", "^", "0.8", ".0"],
+                "nodeType": "PragmaDirective",
+                "src": "42:23:1"
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/openzeppelin-contracts/contracts/access/Ownable.sol",
+                "file": "../lib/openzeppelin-contracts/contracts/access/Ownable.sol",
+                "id": 1138,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1327,
+                "sourceUnit": 3912,
+                "src": "67:83:1",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 1137,
+                            "name": "Ownable",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "75:7:1",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/solmate/src/mixins/ERC4626.sol",
+                "file": "../lib/solmate/src/mixins/ERC4626.sol",
+                "id": 1141,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1327,
+                "sourceUnit": 6286,
+                "src": "151:69:1",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 1139,
+                            "name": "ERC20",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "159:5:1",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    },
+                    {
+                        "foreign": {
+                            "id": 1140,
+                            "name": "ERC4626",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "166:7:1",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/solmate/src/utils/SafeTransferLib.sol",
+                "file": "../lib/solmate/src/utils/SafeTransferLib.sol",
+                "id": 1143,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1327,
+                "sourceUnit": 6886,
+                "src": "221:77:1",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 1142,
+                            "name": "SafeTransferLib",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "229:15:1",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/contracts/LongFarmer.sol",
+                "file": "./LongFarmer.sol",
+                "id": 1144,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 1327,
+                "sourceUnit": 1135,
+                "src": "299:26:1",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "abstract": false,
+                "baseContracts": [
+                    {
+                        "baseName": {
+                            "id": 1146,
+                            "name": "ERC4626",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 6285,
+                            "src": "593:7:1"
+                        },
+                        "id": 1147,
+                        "nodeType": "InheritanceSpecifier",
+                        "src": "593:7:1"
+                    },
+                    {
+                        "baseName": {
+                            "id": 1148,
+                            "name": "Ownable",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 3911,
+                            "src": "602:7:1"
+                        },
+                        "id": 1149,
+                        "nodeType": "InheritanceSpecifier",
+                        "src": "602:7:1"
+                    }
+                ],
+                "canonicalName": "SkewVault",
+                "contractDependencies": [],
+                "contractKind": "contract",
+                "documentation": {
+                    "id": 1145,
+                    "nodeType": "StructuredDocumentation",
+                    "src": "327:243:1",
+                    "text": " @notice An ERC4626 compliant vault for farming long sided skew against tracer perpetual pools\n @dev inherets LongFarmer, which contains skew specific logic\n @dev vault accepts usdc deposits and withdrawals from whitelisted users"
+                },
+                "fullyImplemented": true,
+                "id": 1326,
+                "linearizedBaseContracts": [1326, 3911, 5059, 6285, 6673],
+                "name": "SkewVault",
+                "nameLocation": "580:9:1",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "id": 1153,
+                        "libraryName": {
+                            "id": 1150,
+                            "name": "SafeTransferLib",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 6885,
+                            "src": "622:15:1"
+                        },
+                        "nodeType": "UsingForDirective",
+                        "src": "616:32:1",
+                        "typeName": {
+                            "id": 1152,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 1151,
+                                "name": "ERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6673,
+                                "src": "642:5:1"
+                            },
+                            "referencedDeclaration": 6673,
+                            "src": "642:5:1",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                "typeString": "contract ERC20"
+                            }
+                        }
+                    },
+                    {
+                        "constant": false,
+                        "id": 1156,
+                        "mutability": "mutable",
+                        "name": "longFarmer",
+                        "nameLocation": "664:10:1",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1326,
+                        "src": "653:21:1",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                            "typeString": "contract LongFarmer"
+                        },
+                        "typeName": {
+                            "id": 1155,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 1154,
+                                "name": "LongFarmer",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 1134,
+                                "src": "653:10:1"
+                            },
+                            "referencedDeclaration": 1134,
+                            "src": "653:10:1",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                "typeString": "contract LongFarmer"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "functionSelector": "6f307dc3",
+                        "id": 1159,
+                        "mutability": "immutable",
+                        "name": "underlying",
+                        "nameLocation": "750:10:1",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1326,
+                        "src": "727:33:1",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                            "typeString": "contract ERC20"
+                        },
+                        "typeName": {
+                            "id": 1158,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 1157,
+                                "name": "ERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6673,
+                                "src": "727:5:1"
+                            },
+                            "referencedDeclaration": 6673,
+                            "src": "727:5:1",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                "typeString": "contract ERC20"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": false,
+                        "functionSelector": "372c12b1",
+                        "id": 1163,
+                        "mutability": "mutable",
+                        "name": "whiteList",
+                        "nameLocation": "799:9:1",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 1326,
+                        "src": "767:41:1",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_mapping$_t_address_$_t_bool_$",
+                            "typeString": "mapping(address => bool)"
+                        },
+                        "typeName": {
+                            "id": 1162,
+                            "keyType": {
+                                "id": 1160,
+                                "name": "address",
+                                "nodeType": "ElementaryTypeName",
+                                "src": "775:7:1",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_address",
+                                    "typeString": "address"
+                                }
+                            },
+                            "nodeType": "Mapping",
+                            "src": "767:24:1",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_mapping$_t_address_$_t_bool_$",
+                                "typeString": "mapping(address => bool)"
+                            },
+                            "valueType": {
+                                "id": 1161,
+                                "name": "bool",
+                                "nodeType": "ElementaryTypeName",
+                                "src": "786:4:1",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_bool",
+                                    "typeString": "bool"
+                                }
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 1181,
+                            "nodeType": "Block",
+                            "src": "913:181:1",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 1179,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 1175,
+                                            "name": "underlying",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 1159,
+                                            "src": "923:10:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                "typeString": "contract ERC20"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 1177,
+                                                    "name": "_underlying",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 1165,
+                                                    "src": "942:11:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 1176,
+                                                "name": "ERC20",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6673,
+                                                "src": "936:5:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_contract$_ERC20_$6673_$",
+                                                    "typeString": "type(contract ERC20)"
+                                                }
+                                            },
+                                            "id": 1178,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "936:18:1",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                "typeString": "contract ERC20"
+                                            }
+                                        },
+                                        "src": "923:31:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                                            "typeString": "contract ERC20"
+                                        }
+                                    },
+                                    "id": 1180,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "923:31:1"
+                                }
+                            ]
+                        },
+                        "id": 1182,
+                        "implemented": true,
+                        "kind": "constructor",
+                        "modifiers": [
+                            {
+                                "arguments": [
+                                    {
+                                        "arguments": [
+                                            {
+                                                "id": 1169,
+                                                "name": "_underlying",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1165,
+                                                "src": "876:11:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "id": 1168,
+                                            "name": "ERC20",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 6673,
+                                            "src": "870:5:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_type$_t_contract$_ERC20_$6673_$",
+                                                "typeString": "type(contract ERC20)"
+                                            }
+                                        },
+                                        "id": 1170,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "typeConversion",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "870:18:1",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_ERC20_$6673",
+                                            "typeString": "contract ERC20"
+                                        }
+                                    },
+                                    {
+                                        "hexValue": "5472616365725661756c74",
+                                        "id": 1171,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": true,
+                                        "kind": "string",
+                                        "lValueRequested": false,
+                                        "nodeType": "Literal",
+                                        "src": "890:13:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_stringliteral_4e2393a9904856ed2492e3a7f091c5f4bdbe2e8e6d3ebcd8bab4606dbe142394",
+                                            "typeString": "literal_string \"TracerVault\""
+                                        },
+                                        "value": "TracerVault"
+                                    },
+                                    {
+                                        "hexValue": "54564c54",
+                                        "id": 1172,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": true,
+                                        "kind": "string",
+                                        "lValueRequested": false,
+                                        "nodeType": "Literal",
+                                        "src": "905:6:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_stringliteral_e86607596e46f2e89ac415b1a40e90586f3da868302435f4393bfbccaa14a81a",
+                                            "typeString": "literal_string \"TVLT\""
+                                        },
+                                        "value": "TVLT"
+                                    }
+                                ],
+                                "id": 1173,
+                                "kind": "baseConstructorSpecifier",
+                                "modifierName": {
+                                    "id": 1167,
+                                    "name": "ERC4626",
+                                    "nodeType": "IdentifierPath",
+                                    "referencedDeclaration": 6285,
+                                    "src": "862:7:1"
+                                },
+                                "nodeType": "ModifierInvocation",
+                                "src": "862:50:1"
+                            }
+                        ],
+                        "name": "",
+                        "nameLocation": "-1:-1:-1",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 1166,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 1165,
+                                    "mutability": "mutable",
+                                    "name": "_underlying",
+                                    "nameLocation": "844:11:1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1182,
+                                    "src": "836:19:1",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 1164,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "836:7:1",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "826:35:1"
+                        },
+                        "returnParameters": {
+                            "id": 1174,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "913:0:1"
+                        },
+                        "scope": 1326,
+                        "src": "815:279:1",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "baseFunctions": [6094],
+                        "body": {
+                            "id": 1210,
+                            "nodeType": "Block",
+                            "src": "1162:146:1",
+                            "statements": [
+                                {
+                                    "assignments": [1189],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 1189,
+                                            "mutability": "mutable",
+                                            "name": "bal",
+                                            "nameLocation": "1180:3:1",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 1210,
+                                            "src": "1172:11:1",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 1188,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "1172:7:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 1193,
+                                    "initialValue": {
+                                        "arguments": [],
+                                        "expression": {
+                                            "argumentTypes": [],
+                                            "expression": {
+                                                "id": 1190,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1156,
+                                                "src": "1186:10:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 1191,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "value",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 245,
+                                            "src": "1186:16:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$",
+                                                "typeString": "function () view external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 1192,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1186:18:1",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "1172:32:1"
+                                },
+                                {
+                                    "assignments": [1195],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 1195,
+                                            "mutability": "mutable",
+                                            "name": "_t",
+                                            "nameLocation": "1222:2:1",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 1210,
+                                            "src": "1214:10:1",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 1194,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "1214:7:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 1203,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 1200,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "1256:4:1",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    ],
+                                                    "id": 1199,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1248:7:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 1198,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1248:7:1",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 1201,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1248:13:1",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 1196,
+                                                "name": "underlying",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1159,
+                                                "src": "1227:10:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 1197,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "balanceOf",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6316,
+                                            "src": "1227:20:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (address) view external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 1202,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1227:35:1",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "1214:48:1"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 1206,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 1204,
+                                            "name": "bal",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 1189,
+                                            "src": "1272:3:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "+=",
+                                        "rightHandSide": {
+                                            "id": 1205,
+                                            "name": "_t",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 1195,
+                                            "src": "1279:2:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "1272:9:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 1207,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1272:9:1"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 1208,
+                                        "name": "bal",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 1189,
+                                        "src": "1298:3:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "functionReturnParameters": 1187,
+                                    "id": 1209,
+                                    "nodeType": "Return",
+                                    "src": "1291:10:1"
+                                }
+                            ]
+                        },
+                        "functionSelector": "01e1d114",
+                        "id": 1211,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "totalAssets",
+                        "nameLocation": "1109:11:1",
+                        "nodeType": "FunctionDefinition",
+                        "overrides": {
+                            "id": 1184,
+                            "nodeType": "OverrideSpecifier",
+                            "overrides": [],
+                            "src": "1135:8:1"
+                        },
+                        "parameters": {
+                            "id": 1183,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1120:2:1"
+                        },
+                        "returnParameters": {
+                            "id": 1187,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 1186,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1211,
+                                    "src": "1153:7:1",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 1185,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1153:7:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1152:9:1"
+                        },
+                        "scope": 1326,
+                        "src": "1100:208:1",
+                        "stateMutability": "view",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 1226,
+                            "nodeType": "Block",
+                            "src": "1383:42:1",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 1224,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "baseExpression": {
+                                                "id": 1220,
+                                                "name": "whiteList",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1163,
+                                                "src": "1393:9:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_mapping$_t_address_$_t_bool_$",
+                                                    "typeString": "mapping(address => bool)"
+                                                }
+                                            },
+                                            "id": 1222,
+                                            "indexExpression": {
+                                                "id": 1221,
+                                                "name": "_addr",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1213,
+                                                "src": "1403:5:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "nodeType": "IndexAccess",
+                                            "src": "1393:16:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 1223,
+                                            "name": "status",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 1215,
+                                            "src": "1412:6:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "src": "1393:25:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 1225,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1393:25:1"
+                                }
+                            ]
+                        },
+                        "functionSelector": "8d14e127",
+                        "id": 1227,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [
+                            {
+                                "id": 1218,
+                                "kind": "modifierInvocation",
+                                "modifierName": {
+                                    "id": 1217,
+                                    "name": "onlyOwner",
+                                    "nodeType": "IdentifierPath",
+                                    "referencedDeclaration": 3853,
+                                    "src": "1373:9:1"
+                                },
+                                "nodeType": "ModifierInvocation",
+                                "src": "1373:9:1"
+                            }
+                        ],
+                        "name": "setWhiteList",
+                        "nameLocation": "1323:12:1",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 1216,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 1213,
+                                    "mutability": "mutable",
+                                    "name": "_addr",
+                                    "nameLocation": "1344:5:1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1227,
+                                    "src": "1336:13:1",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 1212,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1336:7:1",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 1215,
+                                    "mutability": "mutable",
+                                    "name": "status",
+                                    "nameLocation": "1356:6:1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1227,
+                                    "src": "1351:11:1",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 1214,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1351:4:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1335:28:1"
+                        },
+                        "returnParameters": {
+                            "id": 1219,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1383:0:1"
+                        },
+                        "scope": 1326,
+                        "src": "1314:111:1",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "body": {
+                            "id": 1264,
+                            "nodeType": "Block",
+                            "src": "1492:285:1",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 1238,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 1234,
+                                            "name": "longFarmer",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 1156,
+                                            "src": "1502:10:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                "typeString": "contract LongFarmer"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 1236,
+                                                    "name": "_longFarmer",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 1229,
+                                                    "src": "1526:11:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 1235,
+                                                "name": "LongFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1134,
+                                                "src": "1515:10:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_contract$_LongFarmer_$1134_$",
+                                                    "typeString": "type(contract LongFarmer)"
+                                                }
+                                            },
+                                            "id": 1237,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "1515:23:1",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                "typeString": "contract LongFarmer"
+                                            }
+                                        },
+                                        "src": "1502:36:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                            "typeString": "contract LongFarmer"
+                                        }
+                                    },
+                                    "id": 1239,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1502:36:1"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 1245,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 1156,
+                                                        "src": "1575:10:1",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 1244,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1567:7:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 1243,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1567:7:1",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 1246,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1567:19:1",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 1247,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1588:4:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 1240,
+                                                "name": "underlying",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1159,
+                                                "src": "1548:10:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 1242,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6390,
+                                            "src": "1548:18:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 1248,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1548:45:1",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 1249,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1548:45:1"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307843336432303532343739644243303130343830416531363230343737374331343639434566664339",
+                                                        "id": 1256,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "1684:42:1",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0xC3d2052479dBC010480Ae16204777C1469CEffC9"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 1255,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1676:7:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 1254,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1676:7:1",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 1257,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1676:51:1",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 1260,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 1156,
+                                                        "src": "1749:10:1",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 1259,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1741:7:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 1258,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1741:7:1",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 1261,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1741:19:1",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                        "id": 1251,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "1609:42:1",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 1250,
+                                                    "name": "ERC20",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 6673,
+                                                    "src": "1603:5:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_contract$_ERC20_$6673_$",
+                                                        "typeString": "type(contract ERC20)"
+                                                    }
+                                                },
+                                                "id": 1252,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1603:49:1",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$6673",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 1253,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "allowance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6322,
+                                            "src": "1603:59:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_view$_t_address_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (address,address) view external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 1262,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1603:167:1",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 1263,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1603:167:1"
+                                }
+                            ]
+                        },
+                        "functionSelector": "400a80ec",
+                        "id": 1265,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [
+                            {
+                                "id": 1232,
+                                "kind": "modifierInvocation",
+                                "modifierName": {
+                                    "id": 1231,
+                                    "name": "onlyOwner",
+                                    "nodeType": "IdentifierPath",
+                                    "referencedDeclaration": 3853,
+                                    "src": "1482:9:1"
+                                },
+                                "nodeType": "ModifierInvocation",
+                                "src": "1482:9:1"
+                            }
+                        ],
+                        "name": "setLongFarmer",
+                        "nameLocation": "1440:13:1",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 1230,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 1229,
+                                    "mutability": "mutable",
+                                    "name": "_longFarmer",
+                                    "nameLocation": "1462:11:1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1265,
+                                    "src": "1454:19:1",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 1228,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1454:7:1",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1453:21:1"
+                        },
+                        "returnParameters": {
+                            "id": 1233,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1492:0:1"
+                        },
+                        "scope": 1326,
+                        "src": "1431:346:1",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "baseFunctions": [6284],
+                        "body": {
+                            "id": 1288,
+                            "nodeType": "Block",
+                            "src": "1863:156:1",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "id": 1279,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "baseExpression": {
+                                                        "id": 1274,
+                                                        "name": "whiteList",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 1163,
+                                                        "src": "1881:9:1",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_address_$_t_bool_$",
+                                                            "typeString": "mapping(address => bool)"
+                                                        }
+                                                    },
+                                                    "id": 1277,
+                                                    "indexExpression": {
+                                                        "expression": {
+                                                            "id": 1275,
+                                                            "name": "msg",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -15,
+                                                            "src": "1891:3:1",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_message",
+                                                                "typeString": "msg"
+                                                            }
+                                                        },
+                                                        "id": 1276,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "sender",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "1891:10:1",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "1881:21:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "hexValue": "74727565",
+                                                    "id": 1278,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "bool",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1906:4:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    },
+                                                    "value": "true"
+                                                },
+                                                "src": "1881:29:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 1273,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "1873:7:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$returns$__$",
+                                                "typeString": "function (bool) pure"
+                                            }
+                                        },
+                                        "id": 1280,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1873:38:1",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 1281,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1873:38:1"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 1285,
+                                                "name": "assets",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1267,
+                                                "src": "2005:6:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 1282,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1156,
+                                                "src": "1986:10:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 1284,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "rxFunds",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1072,
+                                            "src": "1986:18:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$returns$__$",
+                                                "typeString": "function (uint256) external"
+                                            }
+                                        },
+                                        "id": 1286,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1986:26:1",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 1287,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1986:26:1"
+                                }
+                            ]
+                        },
+                        "id": 1289,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "afterDeposit",
+                        "nameLocation": "1792:12:1",
+                        "nodeType": "FunctionDefinition",
+                        "overrides": {
+                            "id": 1271,
+                            "nodeType": "OverrideSpecifier",
+                            "overrides": [],
+                            "src": "1854:8:1"
+                        },
+                        "parameters": {
+                            "id": 1270,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 1267,
+                                    "mutability": "mutable",
+                                    "name": "assets",
+                                    "nameLocation": "1813:6:1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1289,
+                                    "src": "1805:14:1",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 1266,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1805:7:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 1269,
+                                    "mutability": "mutable",
+                                    "name": "shares",
+                                    "nameLocation": "1829:6:1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1289,
+                                    "src": "1821:14:1",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 1268,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1821:7:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1804:32:1"
+                        },
+                        "returnParameters": {
+                            "id": 1272,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1863:0:1"
+                        },
+                        "scope": 1326,
+                        "src": "1783:236:1",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "baseFunctions": [6276],
+                        "body": {
+                            "id": 1312,
+                            "nodeType": "Block",
+                            "src": "2107:95:1",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "id": 1303,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "baseExpression": {
+                                                        "id": 1298,
+                                                        "name": "whiteList",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 1163,
+                                                        "src": "2125:9:1",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_address_$_t_bool_$",
+                                                            "typeString": "mapping(address => bool)"
+                                                        }
+                                                    },
+                                                    "id": 1301,
+                                                    "indexExpression": {
+                                                        "expression": {
+                                                            "id": 1299,
+                                                            "name": "msg",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -15,
+                                                            "src": "2135:3:1",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_message",
+                                                                "typeString": "msg"
+                                                            }
+                                                        },
+                                                        "id": 1300,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "sender",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "2135:10:1",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "2125:21:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "hexValue": "74727565",
+                                                    "id": 1302,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "bool",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "2150:4:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    },
+                                                    "value": "true"
+                                                },
+                                                "src": "2125:29:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 1297,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "2117:7:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$returns$__$",
+                                                "typeString": "function (bool) pure"
+                                            }
+                                        },
+                                        "id": 1304,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2117:38:1",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 1305,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2117:38:1"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 1309,
+                                                "name": "assets",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1291,
+                                                "src": "2188:6:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 1306,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 1156,
+                                                "src": "2165:10:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 1308,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "returnFunds",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1088,
+                                            "src": "2165:22:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$returns$__$",
+                                                "typeString": "function (uint256) external"
+                                            }
+                                        },
+                                        "id": 1310,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2165:30:1",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 1311,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2165:30:1"
+                                }
+                            ]
+                        },
+                        "id": 1313,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "beforeWithdraw",
+                        "nameLocation": "2034:14:1",
+                        "nodeType": "FunctionDefinition",
+                        "overrides": {
+                            "id": 1295,
+                            "nodeType": "OverrideSpecifier",
+                            "overrides": [],
+                            "src": "2098:8:1"
+                        },
+                        "parameters": {
+                            "id": 1294,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 1291,
+                                    "mutability": "mutable",
+                                    "name": "assets",
+                                    "nameLocation": "2057:6:1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1313,
+                                    "src": "2049:14:1",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 1290,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2049:7:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 1293,
+                                    "mutability": "mutable",
+                                    "name": "shares",
+                                    "nameLocation": "2073:6:1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 1313,
+                                    "src": "2065:14:1",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 1292,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2065:7:1",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2048:32:1"
+                        },
+                        "returnParameters": {
+                            "id": 1296,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2107:0:1"
+                        },
+                        "scope": 1326,
+                        "src": "2025:177:1",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 1324,
+                            "nodeType": "Block",
+                            "src": "2233:102:1",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "baseExpression": {
+                                                    "id": 1316,
+                                                    "name": "whiteList",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 1163,
+                                                    "src": "2251:9:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_address_$_t_bool_$",
+                                                        "typeString": "mapping(address => bool)"
+                                                    }
+                                                },
+                                                "id": 1319,
+                                                "indexExpression": {
+                                                    "expression": {
+                                                        "id": 1317,
+                                                        "name": "msg",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -15,
+                                                        "src": "2261:3:1",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_magic_message",
+                                                            "typeString": "msg"
+                                                        }
+                                                    },
+                                                    "id": 1318,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "sender",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "2261:10:1",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "2251:21:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "6f6e6c792077686974656c6973746564206164647265737365732063616e20757365207661756c74",
+                                                "id": 1320,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2274:42:1",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_4cbca2e22c26d082d426ae876636b342bb1b89955b085f57c331fa79c8c3f94a",
+                                                    "typeString": "literal_string \"only whitelisted addresses can use vault\""
+                                                },
+                                                "value": "only whitelisted addresses can use vault"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_4cbca2e22c26d082d426ae876636b342bb1b89955b085f57c331fa79c8c3f94a",
+                                                    "typeString": "literal_string \"only whitelisted addresses can use vault\""
+                                                }
+                                            ],
+                                            "id": 1315,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "2243:7:1",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 1321,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2243:74:1",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 1322,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2243:74:1"
+                                },
+                                {
+                                    "id": 1323,
+                                    "nodeType": "PlaceholderStatement",
+                                    "src": "2327:1:1"
+                                }
+                            ]
+                        },
+                        "id": 1325,
+                        "name": "onlyWhitelist",
+                        "nameLocation": "2217:13:1",
+                        "nodeType": "ModifierDefinition",
+                        "parameters": {
+                            "id": 1314,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2230:2:1"
+                        },
+                        "src": "2208:127:1",
+                        "virtual": false,
+                        "visibility": "internal"
+                    }
+                ],
+                "scope": 1327,
+                "src": "571:1766:1",
+                "usedErrors": []
+            }
+        ],
+        "src": "42:2296:1"
+    }
+}
diff --git a/out/SkewVault.t.sol/Cheats.json b/out/SkewVault.t.sol/Cheats.json
new file mode 100644
index 0000000..f7a74d7
--- /dev/null
+++ b/out/SkewVault.t.sol/Cheats.json
@@ -0,0 +1,5137 @@
+{
+    "abi": [
+        {
+            "inputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "name": "expectRevert",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "prank",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "roll",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "tip",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "x",
+                    "type": "uint256"
+                }
+            ],
+            "name": "warp",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        }
+    ],
+    "bytecode": {
+        "object": "0x",
+        "sourceMap": "",
+        "linkReferences": {}
+    },
+    "deployedBytecode": {
+        "object": "0x",
+        "sourceMap": "",
+        "linkReferences": {}
+    },
+    "ast": {
+        "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/test/SkewVault.t.sol",
+        "exportedSymbols": {
+            "Cheats": [6930],
+            "DSTest": [3806],
+            "ERC20": [4639],
+            "ERC20TokenFaker": [7576],
+            "FakeERC20": [8238],
+            "IERC20": [7595],
+            "IVm": [7442],
+            "LongFarmer": [1134],
+            "SafeMath": [5764],
+            "SkewVault": [1326],
+            "SkewVaulttest": [7276]
+        },
+        "id": 7277,
+        "license": "UNLICENSED",
+        "nodeType": "SourceUnit",
+        "nodes": [
+            {
+                "id": 6887,
+                "literals": ["solidity", "^", "0.8", ".10"],
+                "nodeType": "PragmaDirective",
+                "src": "39:24:19"
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/ds-test/src/test.sol",
+                "file": "../lib/ds-test/src/test.sol",
+                "id": 6888,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 3807,
+                "src": "65:37:19",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/test/utils/ERC20TokenFaker.sol",
+                "file": "./utils/ERC20TokenFaker.sol",
+                "id": 6889,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 7577,
+                "src": "103:37:19",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/test/utils/FakeERC20.sol",
+                "file": "./utils/FakeERC20.sol",
+                "id": 6890,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 8239,
+                "src": "141:31:19",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/contracts/LongFarmer.sol",
+                "file": "../contracts/LongFarmer.sol",
+                "id": 6892,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 1135,
+                "src": "173:55:19",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 6891,
+                            "name": "LongFarmer",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "181:10:19",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/contracts/SkewVault.sol",
+                "file": "../contracts/SkewVault.sol",
+                "id": 6894,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 1327,
+                "src": "229:53:19",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 6893,
+                            "name": "SkewVault",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "237:9:19",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol",
+                "file": "../lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol",
+                "id": 6896,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 4640,
+                "src": "283:84:19",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 6895,
+                            "name": "ERC20",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "291:5:19",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol",
+                "file": "../lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol",
+                "id": 6898,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 5765,
+                "src": "368:89:19",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 6897,
+                            "name": "SafeMath",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "376:8:19",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "abstract": false,
+                "baseContracts": [],
+                "canonicalName": "Cheats",
+                "contractDependencies": [],
+                "contractKind": "interface",
+                "fullyImplemented": false,
+                "id": 6930,
+                "linearizedBaseContracts": [6930],
+                "name": "Cheats",
+                "nameLocation": "565:6:19",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "functionSelector": "e5d6bf02",
+                        "id": 6903,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "warp",
+                        "nameLocation": "587:4:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6901,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6900,
+                                    "mutability": "mutable",
+                                    "name": "x",
+                                    "nameLocation": "600:1:19",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6903,
+                                    "src": "592:9:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6899,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "592:7:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "591:11:19"
+                        },
+                        "returnParameters": {
+                            "id": 6902,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "611:0:19"
+                        },
+                        "scope": 6930,
+                        "src": "578:34:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "f28dceb3",
+                        "id": 6908,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "expectRevert",
+                        "nameLocation": "627:12:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6906,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6905,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6908,
+                                    "src": "640:14:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "calldata",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_calldata_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 6904,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "640:5:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "639:16:19"
+                        },
+                        "returnParameters": {
+                            "id": 6907,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "664:0:19"
+                        },
+                        "scope": 6930,
+                        "src": "618:47:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "1f7b4f30",
+                        "id": 6913,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "roll",
+                        "nameLocation": "680:4:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6911,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6910,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6913,
+                                    "src": "685:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6909,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "685:7:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "684:9:19"
+                        },
+                        "returnParameters": {
+                            "id": 6912,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "702:0:19"
+                        },
+                        "scope": 6930,
+                        "src": "671:32:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "47e50cce",
+                        "id": 6920,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "prank",
+                        "nameLocation": "718:5:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6918,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6915,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6920,
+                                    "src": "724:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6914,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "724:7:19",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6917,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6920,
+                                    "src": "733:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6916,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "733:7:19",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "723:18:19"
+                        },
+                        "returnParameters": {
+                            "id": 6919,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "750:0:19"
+                        },
+                        "scope": 6930,
+                        "src": "709:42:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "d82555f1",
+                        "id": 6929,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "tip",
+                        "nameLocation": "765:3:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6927,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6922,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6929,
+                                    "src": "769:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6921,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "769:7:19",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6924,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6929,
+                                    "src": "778:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6923,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "778:7:19",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6926,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6929,
+                                    "src": "787:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6925,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "787:7:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "768:27:19"
+                        },
+                        "returnParameters": {
+                            "id": 6928,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "804:0:19"
+                        },
+                        "scope": 6930,
+                        "src": "756:49:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    }
+                ],
+                "scope": 7277,
+                "src": "555:252:19",
+                "usedErrors": []
+            },
+            {
+                "abstract": false,
+                "baseContracts": [
+                    {
+                        "baseName": {
+                            "id": 6931,
+                            "name": "DSTest",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 3806,
+                            "src": "835:6:19"
+                        },
+                        "id": 6932,
+                        "nodeType": "InheritanceSpecifier",
+                        "src": "835:6:19"
+                    },
+                    {
+                        "baseName": {
+                            "id": 6933,
+                            "name": "ERC20TokenFaker",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 7576,
+                            "src": "843:15:19"
+                        },
+                        "id": 6934,
+                        "nodeType": "InheritanceSpecifier",
+                        "src": "843:15:19"
+                    }
+                ],
+                "canonicalName": "SkewVaulttest",
+                "contractDependencies": [1134, 1326, 8238],
+                "contractKind": "contract",
+                "fullyImplemented": true,
+                "id": 7276,
+                "linearizedBaseContracts": [7276, 7576, 3806],
+                "name": "SkewVaulttest",
+                "nameLocation": "818:13:19",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "id": 6937,
+                        "libraryName": {
+                            "id": 6935,
+                            "name": "SafeMath",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 5764,
+                            "src": "871:8:19"
+                        },
+                        "nodeType": "UsingForDirective",
+                        "src": "865:27:19",
+                        "typeName": {
+                            "id": 6936,
+                            "name": "uint256",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "884:7:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_uint256",
+                                "typeString": "uint256"
+                            }
+                        }
+                    },
+                    {
+                        "constant": false,
+                        "id": 6940,
+                        "mutability": "mutable",
+                        "name": "longFarmer",
+                        "nameLocation": "908:10:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "897:21:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                            "typeString": "contract LongFarmer"
+                        },
+                        "typeName": {
+                            "id": 6939,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6938,
+                                "name": "LongFarmer",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 1134,
+                                "src": "897:10:19"
+                            },
+                            "referencedDeclaration": 1134,
+                            "src": "897:10:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                "typeString": "contract LongFarmer"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6943,
+                        "mutability": "mutable",
+                        "name": "skewVault",
+                        "nameLocation": "934:9:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "924:19:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                            "typeString": "contract SkewVault"
+                        },
+                        "typeName": {
+                            "id": 6942,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6941,
+                                "name": "SkewVault",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 1326,
+                                "src": "924:9:19"
+                            },
+                            "referencedDeclaration": 1326,
+                            "src": "924:9:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                "typeString": "contract SkewVault"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6946,
+                        "mutability": "mutable",
+                        "name": "fUSD",
+                        "nameLocation": "959:4:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "949:14:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                            "typeString": "contract FakeERC20"
+                        },
+                        "typeName": {
+                            "id": 6945,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6944,
+                                "name": "FakeERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 8238,
+                                "src": "949:9:19"
+                            },
+                            "referencedDeclaration": 8238,
+                            "src": "949:9:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                "typeString": "contract FakeERC20"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6949,
+                        "mutability": "mutable",
+                        "name": "longT",
+                        "nameLocation": "979:5:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "969:15:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                            "typeString": "contract FakeERC20"
+                        },
+                        "typeName": {
+                            "id": 6948,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6947,
+                                "name": "FakeERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 8238,
+                                "src": "969:9:19"
+                            },
+                            "referencedDeclaration": 8238,
+                            "src": "969:9:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                "typeString": "contract FakeERC20"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6952,
+                        "mutability": "mutable",
+                        "name": "tUSD",
+                        "nameLocation": "996:4:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "990:10:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_ERC20_$4639",
+                            "typeString": "contract ERC20"
+                        },
+                        "typeName": {
+                            "id": 6951,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6950,
+                                "name": "ERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 4639,
+                                "src": "990:5:19"
+                            },
+                            "referencedDeclaration": 4639,
+                            "src": "990:5:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ERC20_$4639",
+                                "typeString": "contract ERC20"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "anonymous": false,
+                        "id": 6956,
+                        "name": "Log",
+                        "nameLocation": "1012:3:19",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 6955,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6954,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6956,
+                                    "src": "1016:6:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 6953,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1016:6:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1015:8:19"
+                        },
+                        "src": "1006:18:19"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6962,
+                        "mutability": "mutable",
+                        "name": "usdc",
+                        "nameLocation": "1035:4:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "1029:62:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_ERC20_$4639",
+                            "typeString": "contract ERC20"
+                        },
+                        "typeName": {
+                            "id": 6958,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6957,
+                                "name": "ERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 4639,
+                                "src": "1029:5:19"
+                            },
+                            "referencedDeclaration": 4639,
+                            "src": "1029:5:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ERC20_$4639",
+                                "typeString": "contract ERC20"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                    "id": 6960,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "1048:42:19",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                ],
+                                "id": 6959,
+                                "name": "ERC20",
+                                "nodeType": "Identifier",
+                                "overloadedDeclarations": [],
+                                "referencedDeclaration": 4639,
+                                "src": "1042:5:19",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_contract$_ERC20_$4639_$",
+                                    "typeString": "type(contract ERC20)"
+                                }
+                            },
+                            "id": 6961,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "1042:49:19",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ERC20_$4639",
+                                "typeString": "contract ERC20"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6968,
+                        "mutability": "mutable",
+                        "name": "cheats",
+                        "nameLocation": "1105:6:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "1098:66:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_Cheats_$6930",
+                            "typeString": "contract Cheats"
+                        },
+                        "typeName": {
+                            "id": 6964,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6963,
+                                "name": "Cheats",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6930,
+                                "src": "1098:6:19"
+                            },
+                            "referencedDeclaration": 6930,
+                            "src": "1098:6:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Cheats_$6930",
+                                "typeString": "contract Cheats"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "307837313039373039454366613931613830363236664633393839443638663637463562314444313244",
+                                    "id": 6966,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "1121:42:19",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "value": "0x7109709ECfa91a80626fF3989D68f67F5b1DD12D"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                ],
+                                "id": 6965,
+                                "name": "Cheats",
+                                "nodeType": "Identifier",
+                                "overloadedDeclarations": [],
+                                "referencedDeclaration": 6930,
+                                "src": "1114:6:19",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_contract$_Cheats_$6930_$",
+                                    "typeString": "type(contract Cheats)"
+                                }
+                            },
+                            "id": 6967,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "1114:50:19",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Cheats_$6930",
+                                "typeString": "contract Cheats"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 7080,
+                            "nodeType": "Block",
+                            "src": "1391:875:19",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 6978,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 6971,
+                                            "name": "fUSD",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 6946,
+                                            "src": "1401:4:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                "typeString": "contract FakeERC20"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                            "id": 6975,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "1429:42:19",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            },
+                                                            "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        ],
+                                                        "id": 6974,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "1421:7:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_address_$",
+                                                            "typeString": "type(address)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 6973,
+                                                            "name": "address",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "1421:7:19",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    },
+                                                    "id": 6976,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "typeConversion",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "1421:51:19",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 6972,
+                                                "name": "fakeOutERC20",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 7486,
+                                                "src": "1408:12:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_address_$returns$_t_contract$_FakeERC20_$8238_$",
+                                                    "typeString": "function (address) returns (contract FakeERC20)"
+                                                }
+                                            },
+                                            "id": 6977,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "1408:65:19",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                "typeString": "contract FakeERC20"
+                                            }
+                                        },
+                                        "src": "1401:72:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                            "typeString": "contract FakeERC20"
+                                        }
+                                    },
+                                    "id": 6979,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1401:72:19"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 6989,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 6980,
+                                            "name": "skewVault",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 6943,
+                                            "src": "1483:9:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                "typeString": "contract SkewVault"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 6986,
+                                                            "name": "fUSD",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 6946,
+                                                            "src": "1517:4:19",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                                "typeString": "contract FakeERC20"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                                "typeString": "contract FakeERC20"
+                                                            }
+                                                        ],
+                                                        "id": 6985,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "1509:7:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_address_$",
+                                                            "typeString": "type(address)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 6984,
+                                                            "name": "address",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "1509:7:19",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    },
+                                                    "id": 6987,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "typeConversion",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "1509:13:19",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 6983,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "NewExpression",
+                                                "src": "1495:13:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_creation_nonpayable$_t_address_$returns$_t_contract$_SkewVault_$1326_$",
+                                                    "typeString": "function (address) returns (contract SkewVault)"
+                                                },
+                                                "typeName": {
+                                                    "id": 6982,
+                                                    "nodeType": "UserDefinedTypeName",
+                                                    "pathNode": {
+                                                        "id": 6981,
+                                                        "name": "SkewVault",
+                                                        "nodeType": "IdentifierPath",
+                                                        "referencedDeclaration": 1326,
+                                                        "src": "1499:9:19"
+                                                    },
+                                                    "referencedDeclaration": 1326,
+                                                    "src": "1499:9:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                        "typeString": "contract SkewVault"
+                                                    }
+                                                }
+                                            },
+                                            "id": 6988,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "1495:28:19",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                "typeString": "contract SkewVault"
+                                            }
+                                        },
+                                        "src": "1483:40:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                            "typeString": "contract SkewVault"
+                                        }
+                                    },
+                                    "id": 6990,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1483:40:19"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 6996,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 6991,
+                                            "name": "longFarmer",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 6940,
+                                            "src": "1533:10:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                "typeString": "contract LongFarmer"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [],
+                                            "expression": {
+                                                "argumentTypes": [],
+                                                "id": 6994,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "NewExpression",
+                                                "src": "1546:14:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_creation_nonpayable$__$returns$_t_contract$_LongFarmer_$1134_$",
+                                                    "typeString": "function () returns (contract LongFarmer)"
+                                                },
+                                                "typeName": {
+                                                    "id": 6993,
+                                                    "nodeType": "UserDefinedTypeName",
+                                                    "pathNode": {
+                                                        "id": 6992,
+                                                        "name": "LongFarmer",
+                                                        "nodeType": "IdentifierPath",
+                                                        "referencedDeclaration": 1134,
+                                                        "src": "1550:10:19"
+                                                    },
+                                                    "referencedDeclaration": 1134,
+                                                    "src": "1550:10:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                        "typeString": "contract LongFarmer"
+                                                    }
+                                                }
+                                            },
+                                            "id": 6995,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "1546:16:19",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                "typeString": "contract LongFarmer"
+                                            }
+                                        },
+                                        "src": "1533:29:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                            "typeString": "contract LongFarmer"
+                                        }
+                                    },
+                                    "id": 6997,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1533:29:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7003,
+                                                        "name": "skewVault",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6943,
+                                                        "src": "1593:9:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    ],
+                                                    "id": 7002,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1585:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7001,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1585:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7004,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1585:18:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7005,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1605:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 6998,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "1572:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7000,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "1572:12:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7006,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1572:38:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7007,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1572:38:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7013,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "1645:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7012,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1637:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7011,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1637:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7014,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1637:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7015,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1652:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7008,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "1620:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7010,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "_setBalance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7786,
+                                            "src": "1620:16:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_uint256_$",
+                                                "typeString": "function (address,uint256) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7016,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1620:37:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7017,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1620:37:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7023,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "1698:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7022,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1690:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7021,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1690:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7024,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1690:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "74727565",
+                                                "id": 7025,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1705:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "true"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7018,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "1667:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            },
+                                            "id": 7020,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "setWhiteList",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1227,
+                                            "src": "1667:22:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bool_$returns$__$",
+                                                "typeString": "function (address,bool) external"
+                                            }
+                                        },
+                                        "id": 7026,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1667:43:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7027,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1667:43:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "307838313535613735386130364537653338353139314331313944333531393541613734336342653966",
+                                                "id": 7031,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1755:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0x8155a758a06E7e385191C119D35195Aa743cBe9f"
+                                            },
+                                            {
+                                                "hexValue": "31303030",
+                                                "id": 7032,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1811:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000_by_1",
+                                                    "typeString": "int_const 1000"
+                                                },
+                                                "value": "1000"
+                                            },
+                                            {
+                                                "hexValue": "307843336432303532343739644243303130343830416531363230343737374331343639434566664339",
+                                                "id": 7033,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1829:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0xC3d2052479dBC010480Ae16204777C1469CEffC9"
+                                            },
+                                            {
+                                                "hexValue": "307843423466633430304366353466433632646231373946376530433938363742366635326364353864",
+                                                "id": 7034,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1885:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0xCB4fc400Cf54fC62db179F7e0C9867B6f52cd58d"
+                                            },
+                                            {
+                                                "id": 7035,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "1941:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000_by_1",
+                                                    "typeString": "int_const 1000"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7028,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "1720:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7030,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "initialize",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 215,
+                                            "src": "1720:21:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$_t_address_$_t_address_$_t_contract$_ERC20_$6673_$returns$__$",
+                                                "typeString": "function (address,uint256,address,address,contract ERC20) external"
+                                            }
+                                        },
+                                        "id": 7036,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1720:240:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7037,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1720:240:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7043,
+                                                        "name": "skewVault",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6943,
+                                                        "src": "2002:9:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    ],
+                                                    "id": 7042,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1994:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7041,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1994:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7044,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1994:18:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7038,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "1970:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7040,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "setSkewVault",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1048,
+                                            "src": "1970:23:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 7045,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1970:43:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7046,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1970:43:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7052,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "2055:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7051,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2047:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7050,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2047:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7053,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2047:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7047,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "2023:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            },
+                                            "id": 7049,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "setLongFarmer",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1265,
+                                            "src": "2023:23:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 7054,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2023:44:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7055,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2023:44:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7061,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "2098:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7060,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2090:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7059,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2090:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7062,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2090:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7063,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2111:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7056,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "2077:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7058,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "2077:12:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7064,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2077:39:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7065,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2077:39:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307843336432303532343739644243303130343830416531363230343737374331343639434566664339",
+                                                        "id": 7072,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "2194:42:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0xC3d2052479dBC010480Ae16204777C1469CEffC9"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 7071,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2186:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7070,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2186:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7073,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2186:51:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7076,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "2247:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7075,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2239:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7074,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2239:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7077,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2239:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                        "id": 7067,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "2132:42:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 7066,
+                                                    "name": "ERC20",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4639,
+                                                    "src": "2126:5:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_contract$_ERC20_$4639_$",
+                                                        "typeString": "type(contract ERC20)"
+                                                    }
+                                                },
+                                                "id": 7068,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2126:49:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$4639",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 7069,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "allowance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 4195,
+                                            "src": "2126:59:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_view$_t_address_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (address,address) view external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7078,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2126:133:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7079,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2126:133:19"
+                                }
+                            ]
+                        },
+                        "functionSelector": "0a9254e4",
+                        "id": 7081,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "setUp",
+                        "nameLocation": "1376:5:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6969,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1381:2:19"
+                        },
+                        "returnParameters": {
+                            "id": 6970,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1391:0:19"
+                        },
+                        "scope": 7276,
+                        "src": "1367:899:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 7108,
+                            "nodeType": "Block",
+                            "src": "2302:167:19",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "31303030303030",
+                                                "id": 7087,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2330:7:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                "value": "1000000"
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7090,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "2347:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7089,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2339:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7088,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2339:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7091,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2339:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7084,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "2312:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            },
+                                            "id": 7086,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deposit",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5881,
+                                            "src": "2312:17:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (uint256,address) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7092,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2312:41:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7093,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2312:41:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 7105,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "id": 7101,
+                                                                    "name": "longFarmer",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 6940,
+                                                                    "src": "2438:10:19",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                        "typeString": "contract LongFarmer"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                        "typeString": "contract LongFarmer"
+                                                                    }
+                                                                ],
+                                                                "id": 7100,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "2430:7:19",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_address_$",
+                                                                    "typeString": "type(address)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 7099,
+                                                                    "name": "address",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "2430:7:19",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 7102,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "2430:19:19",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                                    "id": 7096,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "2376:42:19",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    },
+                                                                    "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                ],
+                                                                "id": 7095,
+                                                                "name": "ERC20",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4639,
+                                                                "src": "2370:5:19",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_contract$_ERC20_$4639_$",
+                                                                    "typeString": "type(contract ERC20)"
+                                                                }
+                                                            },
+                                                            "id": 7097,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "2370:49:19",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_ERC20_$4639",
+                                                                "typeString": "contract ERC20"
+                                                            }
+                                                        },
+                                                        "id": 7098,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "balanceOf",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 4152,
+                                                        "src": "2370:59:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_uint256_$",
+                                                            "typeString": "function (address) view external returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 7103,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "2370:80:19",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "hexValue": "31303030303030",
+                                                    "id": 7104,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "2454:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1000000_by_1",
+                                                        "typeString": "int_const 1000000"
+                                                    },
+                                                    "value": "1000000"
+                                                },
+                                                "src": "2370:91:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 7094,
+                                            "name": "assert",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": -3,
+                                            "src": "2363:6:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_assert_pure$_t_bool_$returns$__$",
+                                                "typeString": "function (bool) pure"
+                                            }
+                                        },
+                                        "id": 7106,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2363:99:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7107,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2363:99:19"
+                                }
+                            ]
+                        },
+                        "functionSelector": "7f924c4e",
+                        "id": 7109,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "testDeposit",
+                        "nameLocation": "2281:11:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 7082,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2292:2:19"
+                        },
+                        "returnParameters": {
+                            "id": 7083,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2302:0:19"
+                        },
+                        "scope": 7276,
+                        "src": "2272:197:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 7150,
+                            "nodeType": "Block",
+                            "src": "2506:228:19",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "31303030303030",
+                                                "id": 7115,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2534:7:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                "value": "1000000"
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7118,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "2551:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7117,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2543:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7116,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2543:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7119,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2543:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7112,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "2516:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            },
+                                            "id": 7114,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deposit",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5881,
+                                            "src": "2516:17:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (uint256,address) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7120,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2516:41:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7121,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2516:41:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "31303030303030",
+                                                "id": 7125,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2586:7:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                "value": "1000000"
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7128,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "2603:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7127,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2595:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7126,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2595:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7129,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2595:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7132,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "2618:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7131,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2610:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7130,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2610:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7133,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2610:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7122,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "2567:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            },
+                                            "id": 7124,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "withdraw",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6005,
+                                            "src": "2567:18:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$_t_address_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (uint256,address,address) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7134,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2567:57:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7135,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2567:57:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 7147,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "id": 7143,
+                                                                    "name": "longFarmer",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 6940,
+                                                                    "src": "2709:10:19",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                        "typeString": "contract LongFarmer"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                        "typeString": "contract LongFarmer"
+                                                                    }
+                                                                ],
+                                                                "id": 7142,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "2701:7:19",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_address_$",
+                                                                    "typeString": "type(address)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 7141,
+                                                                    "name": "address",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "2701:7:19",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 7144,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "2701:19:19",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                                    "id": 7138,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "2647:42:19",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    },
+                                                                    "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                ],
+                                                                "id": 7137,
+                                                                "name": "ERC20",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4639,
+                                                                "src": "2641:5:19",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_contract$_ERC20_$4639_$",
+                                                                    "typeString": "type(contract ERC20)"
+                                                                }
+                                                            },
+                                                            "id": 7139,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "2641:49:19",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_ERC20_$4639",
+                                                                "typeString": "contract ERC20"
+                                                            }
+                                                        },
+                                                        "id": 7140,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "balanceOf",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 4152,
+                                                        "src": "2641:59:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_uint256_$",
+                                                            "typeString": "function (address) view external returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 7145,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "2641:80:19",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "hexValue": "30",
+                                                    "id": 7146,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "2725:1:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_0_by_1",
+                                                        "typeString": "int_const 0"
+                                                    },
+                                                    "value": "0"
+                                                },
+                                                "src": "2641:85:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 7136,
+                                            "name": "assert",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": -3,
+                                            "src": "2634:6:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_assert_pure$_t_bool_$returns$__$",
+                                                "typeString": "function (bool) pure"
+                                            }
+                                        },
+                                        "id": 7148,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2634:93:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7149,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2634:93:19"
+                                }
+                            ]
+                        },
+                        "functionSelector": "d509b16c",
+                        "id": 7151,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "testWithdraw",
+                        "nameLocation": "2484:12:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 7110,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2496:2:19"
+                        },
+                        "returnParameters": {
+                            "id": 7111,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2506:0:19"
+                        },
+                        "scope": 7276,
+                        "src": "2475:259:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 7213,
+                            "nodeType": "Block",
+                            "src": "2771:372:19",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 7161,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 7154,
+                                            "name": "longT",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 6949,
+                                            "src": "2781:5:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                "typeString": "contract FakeERC20"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "307834416144633438303837623536396444334536356442653635423064443033363839313736376533",
+                                                            "id": 7158,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "2810:42:19",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            },
+                                                            "value": "0x4AaDc48087b569dD3E65dBe65B0dD036891767e3"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        ],
+                                                        "id": 7157,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "2802:7:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_address_$",
+                                                            "typeString": "type(address)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 7156,
+                                                            "name": "address",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "2802:7:19",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    },
+                                                    "id": 7159,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "typeConversion",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "2802:51:19",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 7155,
+                                                "name": "fakeOutERC20",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 7486,
+                                                "src": "2789:12:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_address_$returns$_t_contract$_FakeERC20_$8238_$",
+                                                    "typeString": "function (address) returns (contract FakeERC20)"
+                                                }
+                                            },
+                                            "id": 7160,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "2789:65:19",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                "typeString": "contract FakeERC20"
+                                            }
+                                        },
+                                        "src": "2781:73:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                            "typeString": "contract FakeERC20"
+                                        }
+                                    },
+                                    "id": 7162,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2781:73:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7168,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "2890:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7167,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2882:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7166,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2882:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7169,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2882:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7170,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2897:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7163,
+                                                "name": "longT",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6949,
+                                                "src": "2864:5:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7165,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "_setBalance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7786,
+                                            "src": "2864:17:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_uint256_$",
+                                                "typeString": "function (address,uint256) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7171,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2864:38:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7172,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2864:38:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7178,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "2937:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7177,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2929:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7176,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2929:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7179,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2929:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7180,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2950:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7173,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "2912:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7175,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "_setBalance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7786,
+                                            "src": "2912:16:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_uint256_$",
+                                                "typeString": "function (address,uint256) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7181,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2912:43:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7182,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2912:43:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [],
+                                        "expression": {
+                                            "argumentTypes": [],
+                                            "expression": {
+                                                "id": 7183,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "2965:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7185,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "setActive",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1020,
+                                            "src": "2965:20:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$__$returns$__$",
+                                                "typeString": "function () external"
+                                            }
+                                        },
+                                        "id": 7186,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2965:22:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7187,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2965:22:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7193,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "3019:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7192,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "3011:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7191,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "3011:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7194,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3011:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7195,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3032:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7188,
+                                                "name": "longT",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6949,
+                                                "src": "2997:5:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7190,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "2997:13:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7196,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2997:40:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7197,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2997:40:19"
+                                },
+                                {
+                                    "assignments": [7199],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 7199,
+                                            "mutability": "mutable",
+                                            "name": "want",
+                                            "nameLocation": "3055:4:19",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 7213,
+                                            "src": "3047:12:19",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 7198,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "3047:7:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 7201,
+                                    "initialValue": {
+                                        "hexValue": "3130303030303030",
+                                        "id": 7200,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": true,
+                                        "kind": "number",
+                                        "lValueRequested": false,
+                                        "nodeType": "Literal",
+                                        "src": "3062:8:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_rational_10000000_by_1",
+                                            "typeString": "int_const 10000000"
+                                        },
+                                        "value": "10000000"
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "3047:23:19"
+                                },
+                                {
+                                    "assignments": [7203],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 7203,
+                                            "mutability": "mutable",
+                                            "name": "_lP",
+                                            "nameLocation": "3088:3:19",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 7213,
+                                            "src": "3080:11:19",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 7202,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "3080:7:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 7205,
+                                    "initialValue": {
+                                        "hexValue": "31",
+                                        "id": 7204,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": true,
+                                        "kind": "number",
+                                        "lValueRequested": false,
+                                        "nodeType": "Literal",
+                                        "src": "3094:1:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_rational_1_by_1",
+                                            "typeString": "int_const 1"
+                                        },
+                                        "value": "1"
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "3080:15:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "3130303030303030",
+                                                "id": 7209,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3122:8:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_10000000_by_1",
+                                                    "typeString": "int_const 10000000"
+                                                },
+                                                "value": "10000000"
+                                            },
+                                            {
+                                                "id": 7210,
+                                                "name": "_lP",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 7203,
+                                                "src": "3132:3:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_rational_10000000_by_1",
+                                                    "typeString": "int_const 10000000"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7206,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "3105:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7208,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "_swap",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 964,
+                                            "src": "3105:16:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$_t_uint256_$returns$_t_uint256_$",
+                                                "typeString": "function (uint256,uint256) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7211,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3105:31:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7212,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3105:31:19"
+                                }
+                            ]
+                        },
+                        "functionSelector": "ac2e92cb",
+                        "id": 7214,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "testLongSwap",
+                        "nameLocation": "2749:12:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 7152,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2761:2:19"
+                        },
+                        "returnParameters": {
+                            "id": 7153,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2771:0:19"
+                        },
+                        "scope": 7276,
+                        "src": "2740:403:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 7274,
+                            "nodeType": "Block",
+                            "src": "3178:1331:19",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7222,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "3213:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7221,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "3205:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7220,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "3205:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7223,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3205:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7224,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3226:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7217,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "3188:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7219,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "_setBalance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7786,
+                                            "src": "3188:16:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_uint256_$",
+                                                "typeString": "function (address,uint256) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7225,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3188:43:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7226,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3188:43:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "307863634330333530433230394636463031443037316333636463323065456235454534413733643830",
+                                                "id": 7230,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3268:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0xccC0350C209F6F01D071c3cdc20eEb5EE4A73d80"
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7231,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3312:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7227,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "3255:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7229,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "3255:12:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7232,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3255:62:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7233,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3255:62:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "307843336432303532343739644243303130343830416531363230343737374331343639434566664339",
+                                                "id": 7237,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3341:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0xC3d2052479dBC010480Ae16204777C1469CEffC9"
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7238,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3385:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7234,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "3328:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7236,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "3328:12:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7239,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3328:62:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7240,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3328:62:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "307838313535613735386130364537653338353139314331313944333531393541613734336342653966",
+                                                "id": 7244,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3413:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0x8155a758a06E7e385191C119D35195Aa743cBe9f"
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7245,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3457:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7241,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "3400:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7243,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "3400:12:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7246,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3400:62:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7247,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3400:62:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7254,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "3540:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7253,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "3532:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7252,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "3532:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7255,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3532:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "307838313535613735386130364537653338353139314331313944333531393541613734336342653966",
+                                                "id": 7256,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3553:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0x8155a758a06E7e385191C119D35195Aa743cBe9f"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                        "id": 7249,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "3478:42:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 7248,
+                                                    "name": "ERC20",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4639,
+                                                    "src": "3472:5:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_contract$_ERC20_$4639_$",
+                                                        "typeString": "type(contract ERC20)"
+                                                    }
+                                                },
+                                                "id": 7250,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3472:49:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$4639",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 7251,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "allowance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 4195,
+                                            "src": "3472:59:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_view$_t_address_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (address,address) view external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7257,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3472:124:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7258,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3472:124:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [],
+                                        "expression": {
+                                            "argumentTypes": [],
+                                            "expression": {
+                                                "id": 7259,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "3606:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7261,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "setActive",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1020,
+                                            "src": "3606:20:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$__$returns$__$",
+                                                "typeString": "function () external"
+                                            }
+                                        },
+                                        "id": 7262,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3606:22:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7263,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3606:22:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "3130303030",
+                                                "id": 7267,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3657:5:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_10000_by_1",
+                                                    "typeString": "int_const 10000"
+                                                },
+                                                "value": "10000"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_rational_10000_by_1",
+                                                    "typeString": "int_const 10000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7264,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "3638:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7266,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "acquire",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 776,
+                                            "src": "3638:18:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$returns$__$",
+                                                "typeString": "function (uint256) external"
+                                            }
+                                        },
+                                        "id": 7268,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3638:25:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7269,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3638:25:19"
+                                },
+                                {
+                                    "eventCall": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "636f6d6d6974",
+                                                "id": 7271,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3682:8:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_a97dd2cbe677d6dda22dd4a01edec54ba307cd2b1f7d130707ba5a29cc019c1d",
+                                                    "typeString": "literal_string \"commit\""
+                                                },
+                                                "value": "commit"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_a97dd2cbe677d6dda22dd4a01edec54ba307cd2b1f7d130707ba5a29cc019c1d",
+                                                    "typeString": "literal_string \"commit\""
+                                                }
+                                            ],
+                                            "id": 7270,
+                                            "name": "Log",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 6956,
+                                            "src": "3678:3:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (string memory)"
+                                            }
+                                        },
+                                        "id": 7272,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3678:13:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7273,
+                                    "nodeType": "EmitStatement",
+                                    "src": "3673:18:19"
+                                }
+                            ]
+                        },
+                        "functionSelector": "e98a7f3a",
+                        "id": 7275,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "testCommit",
+                        "nameLocation": "3158:10:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 7215,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3168:2:19"
+                        },
+                        "returnParameters": {
+                            "id": 7216,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3178:0:19"
+                        },
+                        "scope": 7276,
+                        "src": "3149:1360:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    }
+                ],
+                "scope": 7277,
+                "src": "809:3702:19",
+                "usedErrors": []
+            }
+        ],
+        "src": "39:4473:19"
+    }
+}
diff --git a/out/SkewVault.t.sol/SkewVaulttest.json b/out/SkewVault.t.sol/SkewVaulttest.json
new file mode 100644
index 0000000..bee2961
--- /dev/null
+++ b/out/SkewVault.t.sol/SkewVaulttest.json
@@ -0,0 +1,5399 @@
+{
+    "abi": [
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "name": "Log",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "name": "log",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "log_address",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "name": "log_bytes",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "bytes32",
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "log_bytes32",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "int256",
+                    "name": "",
+                    "type": "int256"
+                }
+            ],
+            "name": "log_int",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "address",
+                    "name": "val",
+                    "type": "address"
+                }
+            ],
+            "name": "log_named_address",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "bytes",
+                    "name": "val",
+                    "type": "bytes"
+                }
+            ],
+            "name": "log_named_bytes",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "bytes32",
+                    "name": "val",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "log_named_bytes32",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "int256",
+                    "name": "val",
+                    "type": "int256"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "decimals",
+                    "type": "uint256"
+                }
+            ],
+            "name": "log_named_decimal_int",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "val",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "decimals",
+                    "type": "uint256"
+                }
+            ],
+            "name": "log_named_decimal_uint",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "int256",
+                    "name": "val",
+                    "type": "int256"
+                }
+            ],
+            "name": "log_named_int",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "val",
+                    "type": "string"
+                }
+            ],
+            "name": "log_named_string",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "val",
+                    "type": "uint256"
+                }
+            ],
+            "name": "log_named_uint",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "name": "log_string",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "log_uint",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "name": "logs",
+            "type": "event"
+        },
+        {
+            "inputs": [],
+            "name": "IS_TEST",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "failed",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "setUp",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "testCommit",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "testDeposit",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "testLongSwap",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "testWithdraw",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        }
+    ],
+    "bytecode": {
+        "object": "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",
+        "sourceMap": "809:3702:19:-:0;;;;;1572:26:5;;;-1:-1:-1;;1572:26:5;1594:4;1572:26;;;181:15:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;164:32:21;;;-1:-1:-1;;;;;164:32:21;;;;;;-1:-1:-1;;;;;;164:32:21;;;;;;;;;-1:-1:-1;202:56:21;;-1:-1:-1;;;;;;202:56:21;;;215:42;202:56;;;;;;1029:62:19;;;;;1048:42;1029:62;;;1098:66;;;;;;;;;;;809:3702;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;",
+        "linkReferences": {}
+    },
+    "deployedBytecode": {
+        "object": "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",
+        "sourceMap": "809:3702:19:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1367:899;;;:::i;:::-;;2272:197;;;:::i;2740:403::-;;;:::i;1819:584:5:-;;;:::i;:::-;;;179:14:23;;172:22;154:41;;142:2;127:18;1819:584:5;;;;;;;2475:259:19;;;:::i;3149:1360::-;;;:::i;1572:26:5:-;;;;;;;;;1367:899:19;1408:65;1429:42;1408:12;:65::i;:::-;1401:4;:72;;-1:-1:-1;;;;;;1401:72:19;-1:-1:-1;;;;;1401:72:19;;;;;;;;;1495:28;;;;;:::i;:::-;-1:-1:-1;;;;;370:32:23;;;352:51;;340:2;325:18;1495:28:19;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1483:9:19;:40;;-1:-1:-1;;;;;;1483:40:19;-1:-1:-1;;;;;1483:40:19;;;;;;;;;;1546:16;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1533:10:19;:29;;-1:-1:-1;;;;;;1533:29:19;-1:-1:-1;;;;;1533:29:19;;;;;;1572:4;;;1593:9;;1572:38;;-1:-1:-1;;;1572:38:19;;:4;;;;:12;;:38;;1593:9;;;;;1605:4;;1572:38;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;1620:4:19;;;:37;;-1:-1:-1;;;1620:37:19;;-1:-1:-1;;;;;1620:4:19;;;;:16;;:37;;1645:4;;1652;;1620:37;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;1667:9:19;;:43;;-1:-1:-1;;;1667:43:19;;1698:4;1667:43;;;1358:51:23;1667:9:19;1425:18:23;;;1418:50;-1:-1:-1;;;;;1667:9:19;;;;:22;;1331:18:23;;1667:43:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1720:10:19;;1941:9;;1720:240;;-1:-1:-1;;;1720:240:19;;1755:42;1720:240;;;1805:34:23;1811:4:19;1855:18:23;;;1848:34;1829:42:19;1898:18:23;;;1891:43;1885:42:19;1950:18:23;;;1943:43;-1:-1:-1;;;;;1941:9:19;;;2002:19:23;;;1995:44;1720:10:19;;;-1:-1:-1;1720:21:19;;-1:-1:-1;1739:19:23;;1720:240:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1970:10:19;;2002:9;;1970:43;;-1:-1:-1;;;1970:43:19;;-1:-1:-1;;;;;2002:9:19;;;1970:43;;;352:51:23;1970:10:19;;;-1:-1:-1;1970:23:19;;-1:-1:-1;325:18:23;;1970:43:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2023:9:19;;2055:10;;2023:44;;-1:-1:-1;;;2023:44:19;;-1:-1:-1;;;;;2055:10:19;;;2023:44;;;352:51:23;2023:9:19;;;-1:-1:-1;2023:23:19;;-1:-1:-1;325:18:23;;2023:44:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2077:4:19;;;2098:10;;2077:39;;-1:-1:-1;;;2077:39:19;;-1:-1:-1;;;;;2077:4:19;;;;-1:-1:-1;2077:12:19;;-1:-1:-1;2077:39:19;;2098:10;;;;;2111:4;;2077:39;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;2247:10:19;;2126:133;;-1:-1:-1;;;2126:133:19;;2194:42;2126:133;;;2262:34:23;-1:-1:-1;;;;;2247:10:19;;;2312:18:23;;;2305:43;2132:42:19;;2126:59;;2197:18:23;;2126:133:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;1367:899::o;2272:197::-;2312:9;;:41;;-1:-1:-1;;;2312:41:19;;2330:7;2312:41;;;2547:25:23;2347:4:19;2588:18:23;;;2581:60;-1:-1:-1;;;;;2312:9:19;;;;:17;;2520:18:23;;2312:41:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;2438:10:19;;2370:80;;-1:-1:-1;;;2370:80:19;;-1:-1:-1;;;;;2438:10:19;;;2370:80;;;352:51:23;2376:42:19;;2370:59;;325:18:23;;2370:80:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2454:7;2370:91;2363:99;;;;:::i;:::-;2272:197::o;2740:403::-;2789:65;2810:42;2789:12;:65::i;:::-;2781:5;:73;;-1:-1:-1;;;;;;2781:73:19;-1:-1:-1;;;;;2781:73:19;;;;;;;;;2864:38;;-1:-1:-1;;;2864:38:19;;:17;;:38;;2890:4;;2897;;2864:38;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;2912:4:19;;;2937:10;;2912:43;;-1:-1:-1;;;2912:43:19;;-1:-1:-1;;;;;2912:4:19;;;;:16;;:43;;2937:10;;2950:4;;2912:43;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;2965:10;;;;;;;;;-1:-1:-1;;;;;2965:10:19;-1:-1:-1;;;;;2965:20:19;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2997:5:19;;3019:10;;2997:40;;-1:-1:-1;;;2997:40:19;;-1:-1:-1;;;;;2997:5:19;;;;-1:-1:-1;2997:13:19;;-1:-1:-1;2997:40:19;;3019:10;;;;3032:4;;2997:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3105:10:19;;:31;;-1:-1:-1;;;3105:31:19;;3062:8;3105:31;;;2973:25:23;;;3094:1:19;3014:18:23;;;3007:34;;;3062:8:19;;3094:1;;-1:-1:-1;;;;;3105:10:19;;;;:16;;2946:18:23;;3105:31:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;2771:372;;2740:403::o;1819:584:5:-;1853:4;1873:7;;;;;;;1869:528;;;-1:-1:-1;1903:7:5;;;;;;;;1819:584::o;1869:528::-;1941:17;2990:42;2978:55;3059:16;1980:374;;2196:43;;2023:20;;1671:64;;2135:34;;2196:43;;1671:64;;-1:-1:-1;;;2221:17:5;2196:43;;;:::i;:::-;;;;-1:-1:-1;;2196:43:5;;;;;;;;;;2086:175;;;2196:43;2086:175;;:::i;:::-;;;;-1:-1:-1;;2086:175:5;;;;;;;;;;2047:232;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2020:259;;;2323:7;2312:27;;;;;;;;;;;;:::i;:::-;2297:42;;2002:352;1980:374;2374:12;1819:584;-1:-1:-1;1819:584:5:o;2475:259:19:-;2516:9;;:41;;-1:-1:-1;;;2516:41:19;;2534:7;2516:41;;;2547:25:23;2551:4:19;2588:18:23;;;2581:60;-1:-1:-1;;;;;2516:9:19;;;;:17;;2520:18:23;;2516:41:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;2567:9:19;;:57;;-1:-1:-1;;;2567:57:19;;2586:7;2567:57;;;4465:25:23;2603:4:19;4544:18:23;;;4537:43;;;4596:18;;;4589:43;-1:-1:-1;;;;;2567:9:19;;;;:18;;4438::23;;2567:57:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;2709:10:19;;2641:80;;-1:-1:-1;;;2641:80:19;;-1:-1:-1;;;;;2709:10:19;;;2641:80;;;352:51:23;2647:42:19;;2641:59;;325:18:23;;2641:80:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:85;2634:93;;;;:::i;3149:1360::-;3188:4;;;3213:10;;3188:43;;-1:-1:-1;;;3188:43:19;;-1:-1:-1;;;;;3188:4:19;;;;:16;;:43;;3213:10;;3226:4;;3188:43;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3255:4:19;;;:62;;-1:-1:-1;;;3255:62:19;;-1:-1:-1;;;;;3255:4:19;;;;:12;;:62;;3268:42;;3312:4;;3255:62;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3328:4:19;;;:62;;-1:-1:-1;;;3328:62:19;;-1:-1:-1;;;;;3328:4:19;;;;:12;;:62;;3341:42;;3385:4;;3328:62;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3400:4:19;;;:62;;-1:-1:-1;;;3400:62:19;;-1:-1:-1;;;;;3400:4:19;;;;:12;;:62;;3413:42;;3457:4;;3400:62;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3540:10:19;;3472:124;;-1:-1:-1;;;3472:124:19;;-1:-1:-1;;;;;3540:10:19;;;3472:124;;;2262:34:23;3553:42:19;2312:18:23;;;2305:43;3478:42:19;;3472:59;;2197:18:23;;3472:124:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;3606:10;;;;;;;;;-1:-1:-1;;;;;3606:10:19;-1:-1:-1;;;;;3606:20:19;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;3638:10:19;;:25;;-1:-1:-1;;;3638:25:19;;3657:5;3638:25;;;4801::23;-1:-1:-1;;;;;3638:10:19;;;;-1:-1:-1;3638:18:19;;-1:-1:-1;4774:18:23;;3638:25:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3678:13;;;;;5039:2:23;5021:21;;;5078:1;5058:18;;;5051:29;-1:-1:-1;;;5111:2:23;5096:18;;5089:36;5157:2;5142:18;;4837:329;3678:13:19;;;;;;;;3149:1360::o;265:176:21:-;320:20;352:34;360:5;375:4;;;;;;;;;-1:-1:-1;;;;;375:4:21;-1:-1:-1;;;;;367:18:21;;;;;;;;;;;;;;;;;;;;;;;;352:7;:34::i;:::-;-1:-1:-1;427:5:21;265:176::o;528:275::-;647:13;663:18;676:4;663:12;:18::i;:::-;691:2;;706:9;;;-1:-1:-1;;;;;706:9:21;;;;;;;;;;;;;;;;;;647:34;;-1:-1:-1;691:2:21;;;:7;;647:34;;691:2;;706:9;;;;;691:25;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;777:2:21;;:19;;-1:-1:-1;;;777:19:21;;-1:-1:-1;;;;;777:2:21;;;;-1:-1:-1;777:7:21;;-1:-1:-1;777:19:21;;785:4;;791;;777:19;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;586:217;528:275;;:::o;990:128::-;1043:13;1084:26;1100:4;1109:1;1084:26;:::i;:::-;1068:43;990:128;-1:-1:-1;;990:128:21:o;-1:-1:-1:-;;;;;;;;:::o;:::-;;;;;;;;:::o;414:300:23:-;-1:-1:-1;;;;;632:32:23;;;;614:51;;696:2;681:18;;674:34;602:2;587:18;;414:300::o;719:277::-;786:6;839:2;827:9;818:7;814:23;810:32;807:52;;;855:1;852;845:12;807:52;887:9;881:16;940:5;933:13;926:21;919:5;916:32;906:60;;962:1;959;952:12;906:60;985:5;719:277;-1:-1:-1;;;719:277:23:o;1001:184::-;1071:6;1124:2;1112:9;1103:7;1099:23;1095:32;1092:52;;;1140:1;1137;1130:12;1092:52;-1:-1:-1;1163:16:23;;1001:184;-1:-1:-1;1001:184:23:o;2652:127::-;2713:10;2708:3;2704:20;2701:1;2694:31;2744:4;2741:1;2734:15;2768:4;2765:1;2758:15;3331:258;3403:1;3413:113;3427:6;3424:1;3421:13;3413:113;;;3503:11;;;3497:18;3484:11;;;3477:39;3449:2;3442:10;3413:113;;;3544:6;3541:1;3538:13;3535:48;;;3579:1;3570:6;3565:3;3561:16;3554:27;3535:48;;3331:258;;;:::o;3594:371::-;-1:-1:-1;;;;;;3779:33:23;;3767:46;;3836:13;;3749:3;;3858:61;3836:13;3908:1;3899:11;;3892:4;3880:17;;3858:61;:::i;:::-;3939:16;;;;3957:1;3935:24;;3594:371;-1:-1:-1;;;3594:371:23:o;3970:274::-;4099:3;4137:6;4131:13;4153:53;4199:6;4194:3;4187:4;4179:6;4175:17;4153:53;:::i;:::-;4222:16;;;;;3970:274;-1:-1:-1;;3970:274:23:o;5171:478::-;5375:1;5371;5366:3;5362:11;5358:19;5350:6;5346:32;5335:9;5328:51;5415:2;5410;5399:9;5395:18;5388:30;5309:4;5447:6;5441:13;5490:6;5485:2;5474:9;5470:18;5463:34;5506:66;5565:6;5560:2;5549:9;5545:18;5540:2;5532:6;5528:15;5506:66;:::i;:::-;5633:2;5612:15;-1:-1:-1;;5608:29:23;5593:45;;;;5640:2;5589:54;;5171:478;-1:-1:-1;;;5171:478:23:o;5654:335::-;5694:3;-1:-1:-1;;;;;5761:10:23;;;5791;;;5821:12;;;5813:21;;5810:144;;;5876:10;5871:3;5867:20;5864:1;5857:31;5911:4;5908:1;5901:15;5939:4;5936:1;5929:15;5810:144;5970:13;;5654:335;-1:-1:-1;;;;5654:335:23:o",
+        "linkReferences": {}
+    },
+    "ast": {
+        "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/test/SkewVault.t.sol",
+        "exportedSymbols": {
+            "Cheats": [6930],
+            "DSTest": [3806],
+            "ERC20": [4639],
+            "ERC20TokenFaker": [7576],
+            "FakeERC20": [8238],
+            "IERC20": [7595],
+            "IVm": [7442],
+            "LongFarmer": [1134],
+            "SafeMath": [5764],
+            "SkewVault": [1326],
+            "SkewVaulttest": [7276]
+        },
+        "id": 7277,
+        "license": "UNLICENSED",
+        "nodeType": "SourceUnit",
+        "nodes": [
+            {
+                "id": 6887,
+                "literals": ["solidity", "^", "0.8", ".10"],
+                "nodeType": "PragmaDirective",
+                "src": "39:24:19"
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/ds-test/src/test.sol",
+                "file": "../lib/ds-test/src/test.sol",
+                "id": 6888,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 3807,
+                "src": "65:37:19",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/test/utils/ERC20TokenFaker.sol",
+                "file": "./utils/ERC20TokenFaker.sol",
+                "id": 6889,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 7577,
+                "src": "103:37:19",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/test/utils/FakeERC20.sol",
+                "file": "./utils/FakeERC20.sol",
+                "id": 6890,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 8239,
+                "src": "141:31:19",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/contracts/LongFarmer.sol",
+                "file": "../contracts/LongFarmer.sol",
+                "id": 6892,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 1135,
+                "src": "173:55:19",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 6891,
+                            "name": "LongFarmer",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "181:10:19",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/contracts/SkewVault.sol",
+                "file": "../contracts/SkewVault.sol",
+                "id": 6894,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 1327,
+                "src": "229:53:19",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 6893,
+                            "name": "SkewVault",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "237:9:19",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol",
+                "file": "../lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol",
+                "id": 6896,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 4640,
+                "src": "283:84:19",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 6895,
+                            "name": "ERC20",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "291:5:19",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol",
+                "file": "../lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol",
+                "id": 6898,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 7277,
+                "sourceUnit": 5765,
+                "src": "368:89:19",
+                "symbolAliases": [
+                    {
+                        "foreign": {
+                            "id": 6897,
+                            "name": "SafeMath",
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "src": "376:8:19",
+                            "typeDescriptions": {}
+                        },
+                        "nameLocation": "-1:-1:-1"
+                    }
+                ],
+                "unitAlias": ""
+            },
+            {
+                "abstract": false,
+                "baseContracts": [],
+                "canonicalName": "Cheats",
+                "contractDependencies": [],
+                "contractKind": "interface",
+                "fullyImplemented": false,
+                "id": 6930,
+                "linearizedBaseContracts": [6930],
+                "name": "Cheats",
+                "nameLocation": "565:6:19",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "functionSelector": "e5d6bf02",
+                        "id": 6903,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "warp",
+                        "nameLocation": "587:4:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6901,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6900,
+                                    "mutability": "mutable",
+                                    "name": "x",
+                                    "nameLocation": "600:1:19",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6903,
+                                    "src": "592:9:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6899,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "592:7:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "591:11:19"
+                        },
+                        "returnParameters": {
+                            "id": 6902,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "611:0:19"
+                        },
+                        "scope": 6930,
+                        "src": "578:34:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "f28dceb3",
+                        "id": 6908,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "expectRevert",
+                        "nameLocation": "627:12:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6906,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6905,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6908,
+                                    "src": "640:14:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "calldata",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_calldata_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 6904,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "640:5:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "639:16:19"
+                        },
+                        "returnParameters": {
+                            "id": 6907,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "664:0:19"
+                        },
+                        "scope": 6930,
+                        "src": "618:47:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "1f7b4f30",
+                        "id": 6913,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "roll",
+                        "nameLocation": "680:4:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6911,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6910,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6913,
+                                    "src": "685:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6909,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "685:7:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "684:9:19"
+                        },
+                        "returnParameters": {
+                            "id": 6912,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "702:0:19"
+                        },
+                        "scope": 6930,
+                        "src": "671:32:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "47e50cce",
+                        "id": 6920,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "prank",
+                        "nameLocation": "718:5:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6918,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6915,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6920,
+                                    "src": "724:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6914,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "724:7:19",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6917,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6920,
+                                    "src": "733:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6916,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "733:7:19",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "723:18:19"
+                        },
+                        "returnParameters": {
+                            "id": 6919,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "750:0:19"
+                        },
+                        "scope": 6930,
+                        "src": "709:42:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "d82555f1",
+                        "id": 6929,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "tip",
+                        "nameLocation": "765:3:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6927,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6922,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6929,
+                                    "src": "769:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6921,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "769:7:19",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6924,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6929,
+                                    "src": "778:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6923,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "778:7:19",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6926,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6929,
+                                    "src": "787:7:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6925,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "787:7:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "768:27:19"
+                        },
+                        "returnParameters": {
+                            "id": 6928,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "804:0:19"
+                        },
+                        "scope": 6930,
+                        "src": "756:49:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    }
+                ],
+                "scope": 7277,
+                "src": "555:252:19",
+                "usedErrors": []
+            },
+            {
+                "abstract": false,
+                "baseContracts": [
+                    {
+                        "baseName": {
+                            "id": 6931,
+                            "name": "DSTest",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 3806,
+                            "src": "835:6:19"
+                        },
+                        "id": 6932,
+                        "nodeType": "InheritanceSpecifier",
+                        "src": "835:6:19"
+                    },
+                    {
+                        "baseName": {
+                            "id": 6933,
+                            "name": "ERC20TokenFaker",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 7576,
+                            "src": "843:15:19"
+                        },
+                        "id": 6934,
+                        "nodeType": "InheritanceSpecifier",
+                        "src": "843:15:19"
+                    }
+                ],
+                "canonicalName": "SkewVaulttest",
+                "contractDependencies": [1134, 1326, 8238],
+                "contractKind": "contract",
+                "fullyImplemented": true,
+                "id": 7276,
+                "linearizedBaseContracts": [7276, 7576, 3806],
+                "name": "SkewVaulttest",
+                "nameLocation": "818:13:19",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "id": 6937,
+                        "libraryName": {
+                            "id": 6935,
+                            "name": "SafeMath",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 5764,
+                            "src": "871:8:19"
+                        },
+                        "nodeType": "UsingForDirective",
+                        "src": "865:27:19",
+                        "typeName": {
+                            "id": 6936,
+                            "name": "uint256",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "884:7:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_uint256",
+                                "typeString": "uint256"
+                            }
+                        }
+                    },
+                    {
+                        "constant": false,
+                        "id": 6940,
+                        "mutability": "mutable",
+                        "name": "longFarmer",
+                        "nameLocation": "908:10:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "897:21:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                            "typeString": "contract LongFarmer"
+                        },
+                        "typeName": {
+                            "id": 6939,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6938,
+                                "name": "LongFarmer",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 1134,
+                                "src": "897:10:19"
+                            },
+                            "referencedDeclaration": 1134,
+                            "src": "897:10:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                "typeString": "contract LongFarmer"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6943,
+                        "mutability": "mutable",
+                        "name": "skewVault",
+                        "nameLocation": "934:9:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "924:19:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                            "typeString": "contract SkewVault"
+                        },
+                        "typeName": {
+                            "id": 6942,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6941,
+                                "name": "SkewVault",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 1326,
+                                "src": "924:9:19"
+                            },
+                            "referencedDeclaration": 1326,
+                            "src": "924:9:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                "typeString": "contract SkewVault"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6946,
+                        "mutability": "mutable",
+                        "name": "fUSD",
+                        "nameLocation": "959:4:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "949:14:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                            "typeString": "contract FakeERC20"
+                        },
+                        "typeName": {
+                            "id": 6945,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6944,
+                                "name": "FakeERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 8238,
+                                "src": "949:9:19"
+                            },
+                            "referencedDeclaration": 8238,
+                            "src": "949:9:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                "typeString": "contract FakeERC20"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6949,
+                        "mutability": "mutable",
+                        "name": "longT",
+                        "nameLocation": "979:5:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "969:15:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                            "typeString": "contract FakeERC20"
+                        },
+                        "typeName": {
+                            "id": 6948,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6947,
+                                "name": "FakeERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 8238,
+                                "src": "969:9:19"
+                            },
+                            "referencedDeclaration": 8238,
+                            "src": "969:9:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                "typeString": "contract FakeERC20"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6952,
+                        "mutability": "mutable",
+                        "name": "tUSD",
+                        "nameLocation": "996:4:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "990:10:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_ERC20_$4639",
+                            "typeString": "contract ERC20"
+                        },
+                        "typeName": {
+                            "id": 6951,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6950,
+                                "name": "ERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 4639,
+                                "src": "990:5:19"
+                            },
+                            "referencedDeclaration": 4639,
+                            "src": "990:5:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ERC20_$4639",
+                                "typeString": "contract ERC20"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "anonymous": false,
+                        "id": 6956,
+                        "name": "Log",
+                        "nameLocation": "1012:3:19",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 6955,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6954,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6956,
+                                    "src": "1016:6:19",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 6953,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1016:6:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1015:8:19"
+                        },
+                        "src": "1006:18:19"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6962,
+                        "mutability": "mutable",
+                        "name": "usdc",
+                        "nameLocation": "1035:4:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "1029:62:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_ERC20_$4639",
+                            "typeString": "contract ERC20"
+                        },
+                        "typeName": {
+                            "id": 6958,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6957,
+                                "name": "ERC20",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 4639,
+                                "src": "1029:5:19"
+                            },
+                            "referencedDeclaration": 4639,
+                            "src": "1029:5:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ERC20_$4639",
+                                "typeString": "contract ERC20"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                    "id": 6960,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "1048:42:19",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                ],
+                                "id": 6959,
+                                "name": "ERC20",
+                                "nodeType": "Identifier",
+                                "overloadedDeclarations": [],
+                                "referencedDeclaration": 4639,
+                                "src": "1042:5:19",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_contract$_ERC20_$4639_$",
+                                    "typeString": "type(contract ERC20)"
+                                }
+                            },
+                            "id": 6961,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "1042:49:19",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_ERC20_$4639",
+                                "typeString": "contract ERC20"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 6968,
+                        "mutability": "mutable",
+                        "name": "cheats",
+                        "nameLocation": "1105:6:19",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 7276,
+                        "src": "1098:66:19",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_Cheats_$6930",
+                            "typeString": "contract Cheats"
+                        },
+                        "typeName": {
+                            "id": 6964,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 6963,
+                                "name": "Cheats",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6930,
+                                "src": "1098:6:19"
+                            },
+                            "referencedDeclaration": 6930,
+                            "src": "1098:6:19",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Cheats_$6930",
+                                "typeString": "contract Cheats"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "307837313039373039454366613931613830363236664633393839443638663637463562314444313244",
+                                    "id": 6966,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "1121:42:19",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "value": "0x7109709ECfa91a80626fF3989D68f67F5b1DD12D"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                ],
+                                "id": 6965,
+                                "name": "Cheats",
+                                "nodeType": "Identifier",
+                                "overloadedDeclarations": [],
+                                "referencedDeclaration": 6930,
+                                "src": "1114:6:19",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_contract$_Cheats_$6930_$",
+                                    "typeString": "type(contract Cheats)"
+                                }
+                            },
+                            "id": 6967,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "1114:50:19",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Cheats_$6930",
+                                "typeString": "contract Cheats"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 7080,
+                            "nodeType": "Block",
+                            "src": "1391:875:19",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 6978,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 6971,
+                                            "name": "fUSD",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 6946,
+                                            "src": "1401:4:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                "typeString": "contract FakeERC20"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                            "id": 6975,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "1429:42:19",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            },
+                                                            "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        ],
+                                                        "id": 6974,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "1421:7:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_address_$",
+                                                            "typeString": "type(address)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 6973,
+                                                            "name": "address",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "1421:7:19",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    },
+                                                    "id": 6976,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "typeConversion",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "1421:51:19",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 6972,
+                                                "name": "fakeOutERC20",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 7486,
+                                                "src": "1408:12:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_address_$returns$_t_contract$_FakeERC20_$8238_$",
+                                                    "typeString": "function (address) returns (contract FakeERC20)"
+                                                }
+                                            },
+                                            "id": 6977,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "1408:65:19",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                "typeString": "contract FakeERC20"
+                                            }
+                                        },
+                                        "src": "1401:72:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                            "typeString": "contract FakeERC20"
+                                        }
+                                    },
+                                    "id": 6979,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1401:72:19"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 6989,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 6980,
+                                            "name": "skewVault",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 6943,
+                                            "src": "1483:9:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                "typeString": "contract SkewVault"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 6986,
+                                                            "name": "fUSD",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 6946,
+                                                            "src": "1517:4:19",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                                "typeString": "contract FakeERC20"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                                "typeString": "contract FakeERC20"
+                                                            }
+                                                        ],
+                                                        "id": 6985,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "1509:7:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_address_$",
+                                                            "typeString": "type(address)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 6984,
+                                                            "name": "address",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "1509:7:19",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    },
+                                                    "id": 6987,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "typeConversion",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "1509:13:19",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 6983,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "NewExpression",
+                                                "src": "1495:13:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_creation_nonpayable$_t_address_$returns$_t_contract$_SkewVault_$1326_$",
+                                                    "typeString": "function (address) returns (contract SkewVault)"
+                                                },
+                                                "typeName": {
+                                                    "id": 6982,
+                                                    "nodeType": "UserDefinedTypeName",
+                                                    "pathNode": {
+                                                        "id": 6981,
+                                                        "name": "SkewVault",
+                                                        "nodeType": "IdentifierPath",
+                                                        "referencedDeclaration": 1326,
+                                                        "src": "1499:9:19"
+                                                    },
+                                                    "referencedDeclaration": 1326,
+                                                    "src": "1499:9:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                        "typeString": "contract SkewVault"
+                                                    }
+                                                }
+                                            },
+                                            "id": 6988,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "1495:28:19",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                "typeString": "contract SkewVault"
+                                            }
+                                        },
+                                        "src": "1483:40:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                            "typeString": "contract SkewVault"
+                                        }
+                                    },
+                                    "id": 6990,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1483:40:19"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 6996,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 6991,
+                                            "name": "longFarmer",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 6940,
+                                            "src": "1533:10:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                "typeString": "contract LongFarmer"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [],
+                                            "expression": {
+                                                "argumentTypes": [],
+                                                "id": 6994,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "NewExpression",
+                                                "src": "1546:14:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_creation_nonpayable$__$returns$_t_contract$_LongFarmer_$1134_$",
+                                                    "typeString": "function () returns (contract LongFarmer)"
+                                                },
+                                                "typeName": {
+                                                    "id": 6993,
+                                                    "nodeType": "UserDefinedTypeName",
+                                                    "pathNode": {
+                                                        "id": 6992,
+                                                        "name": "LongFarmer",
+                                                        "nodeType": "IdentifierPath",
+                                                        "referencedDeclaration": 1134,
+                                                        "src": "1550:10:19"
+                                                    },
+                                                    "referencedDeclaration": 1134,
+                                                    "src": "1550:10:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                        "typeString": "contract LongFarmer"
+                                                    }
+                                                }
+                                            },
+                                            "id": 6995,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "1546:16:19",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                "typeString": "contract LongFarmer"
+                                            }
+                                        },
+                                        "src": "1533:29:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                            "typeString": "contract LongFarmer"
+                                        }
+                                    },
+                                    "id": 6997,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1533:29:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7003,
+                                                        "name": "skewVault",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6943,
+                                                        "src": "1593:9:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    ],
+                                                    "id": 7002,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1585:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7001,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1585:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7004,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1585:18:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7005,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1605:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 6998,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "1572:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7000,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "1572:12:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7006,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1572:38:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7007,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1572:38:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7013,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "1645:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7012,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1637:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7011,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1637:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7014,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1637:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7015,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1652:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7008,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "1620:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7010,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "_setBalance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7786,
+                                            "src": "1620:16:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_uint256_$",
+                                                "typeString": "function (address,uint256) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7016,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1620:37:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7017,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1620:37:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7023,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "1698:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7022,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1690:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7021,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1690:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7024,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1690:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "74727565",
+                                                "id": 7025,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1705:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "true"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7018,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "1667:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            },
+                                            "id": 7020,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "setWhiteList",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1227,
+                                            "src": "1667:22:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bool_$returns$__$",
+                                                "typeString": "function (address,bool) external"
+                                            }
+                                        },
+                                        "id": 7026,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1667:43:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7027,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1667:43:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "307838313535613735386130364537653338353139314331313944333531393541613734336342653966",
+                                                "id": 7031,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1755:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0x8155a758a06E7e385191C119D35195Aa743cBe9f"
+                                            },
+                                            {
+                                                "hexValue": "31303030",
+                                                "id": 7032,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1811:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000_by_1",
+                                                    "typeString": "int_const 1000"
+                                                },
+                                                "value": "1000"
+                                            },
+                                            {
+                                                "hexValue": "307843336432303532343739644243303130343830416531363230343737374331343639434566664339",
+                                                "id": 7033,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1829:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0xC3d2052479dBC010480Ae16204777C1469CEffC9"
+                                            },
+                                            {
+                                                "hexValue": "307843423466633430304366353466433632646231373946376530433938363742366635326364353864",
+                                                "id": 7034,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "1885:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0xCB4fc400Cf54fC62db179F7e0C9867B6f52cd58d"
+                                            },
+                                            {
+                                                "id": 7035,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "1941:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000_by_1",
+                                                    "typeString": "int_const 1000"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7028,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "1720:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7030,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "initialize",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 215,
+                                            "src": "1720:21:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$_t_address_$_t_address_$_t_contract$_ERC20_$6673_$returns$__$",
+                                                "typeString": "function (address,uint256,address,address,contract ERC20) external"
+                                            }
+                                        },
+                                        "id": 7036,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1720:240:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7037,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1720:240:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7043,
+                                                        "name": "skewVault",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6943,
+                                                        "src": "2002:9:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                            "typeString": "contract SkewVault"
+                                                        }
+                                                    ],
+                                                    "id": 7042,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "1994:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7041,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "1994:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7044,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "1994:18:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7038,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "1970:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7040,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "setSkewVault",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1048,
+                                            "src": "1970:23:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 7045,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1970:43:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7046,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1970:43:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7052,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "2055:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7051,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2047:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7050,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2047:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7053,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2047:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7047,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "2023:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            },
+                                            "id": 7049,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "setLongFarmer",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1265,
+                                            "src": "2023:23:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 7054,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2023:44:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7055,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2023:44:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7061,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "2098:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7060,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2090:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7059,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2090:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7062,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2090:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7063,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2111:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7056,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "2077:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7058,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "2077:12:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7064,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2077:39:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7065,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2077:39:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307843336432303532343739644243303130343830416531363230343737374331343639434566664339",
+                                                        "id": 7072,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "2194:42:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0xC3d2052479dBC010480Ae16204777C1469CEffC9"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 7071,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2186:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7070,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2186:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7073,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2186:51:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7076,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "2247:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7075,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2239:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7074,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2239:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7077,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2239:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                        "id": 7067,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "2132:42:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 7066,
+                                                    "name": "ERC20",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4639,
+                                                    "src": "2126:5:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_contract$_ERC20_$4639_$",
+                                                        "typeString": "type(contract ERC20)"
+                                                    }
+                                                },
+                                                "id": 7068,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2126:49:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$4639",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 7069,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "allowance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 4195,
+                                            "src": "2126:59:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_view$_t_address_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (address,address) view external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7078,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2126:133:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7079,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2126:133:19"
+                                }
+                            ]
+                        },
+                        "functionSelector": "0a9254e4",
+                        "id": 7081,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "setUp",
+                        "nameLocation": "1376:5:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6969,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1381:2:19"
+                        },
+                        "returnParameters": {
+                            "id": 6970,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1391:0:19"
+                        },
+                        "scope": 7276,
+                        "src": "1367:899:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 7108,
+                            "nodeType": "Block",
+                            "src": "2302:167:19",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "31303030303030",
+                                                "id": 7087,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2330:7:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                "value": "1000000"
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7090,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "2347:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7089,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2339:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7088,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2339:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7091,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2339:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7084,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "2312:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            },
+                                            "id": 7086,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deposit",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5881,
+                                            "src": "2312:17:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (uint256,address) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7092,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2312:41:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7093,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2312:41:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 7105,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "id": 7101,
+                                                                    "name": "longFarmer",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 6940,
+                                                                    "src": "2438:10:19",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                        "typeString": "contract LongFarmer"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                        "typeString": "contract LongFarmer"
+                                                                    }
+                                                                ],
+                                                                "id": 7100,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "2430:7:19",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_address_$",
+                                                                    "typeString": "type(address)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 7099,
+                                                                    "name": "address",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "2430:7:19",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 7102,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "2430:19:19",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                                    "id": 7096,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "2376:42:19",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    },
+                                                                    "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                ],
+                                                                "id": 7095,
+                                                                "name": "ERC20",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4639,
+                                                                "src": "2370:5:19",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_contract$_ERC20_$4639_$",
+                                                                    "typeString": "type(contract ERC20)"
+                                                                }
+                                                            },
+                                                            "id": 7097,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "2370:49:19",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_ERC20_$4639",
+                                                                "typeString": "contract ERC20"
+                                                            }
+                                                        },
+                                                        "id": 7098,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "balanceOf",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 4152,
+                                                        "src": "2370:59:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_uint256_$",
+                                                            "typeString": "function (address) view external returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 7103,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "2370:80:19",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "hexValue": "31303030303030",
+                                                    "id": 7104,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "2454:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1000000_by_1",
+                                                        "typeString": "int_const 1000000"
+                                                    },
+                                                    "value": "1000000"
+                                                },
+                                                "src": "2370:91:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 7094,
+                                            "name": "assert",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": -3,
+                                            "src": "2363:6:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_assert_pure$_t_bool_$returns$__$",
+                                                "typeString": "function (bool) pure"
+                                            }
+                                        },
+                                        "id": 7106,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2363:99:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7107,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2363:99:19"
+                                }
+                            ]
+                        },
+                        "functionSelector": "7f924c4e",
+                        "id": 7109,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "testDeposit",
+                        "nameLocation": "2281:11:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 7082,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2292:2:19"
+                        },
+                        "returnParameters": {
+                            "id": 7083,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2302:0:19"
+                        },
+                        "scope": 7276,
+                        "src": "2272:197:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 7150,
+                            "nodeType": "Block",
+                            "src": "2506:228:19",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "31303030303030",
+                                                "id": 7115,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2534:7:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                "value": "1000000"
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7118,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "2551:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7117,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2543:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7116,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2543:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7119,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2543:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7112,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "2516:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            },
+                                            "id": 7114,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deposit",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5881,
+                                            "src": "2516:17:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (uint256,address) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7120,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2516:41:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7121,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2516:41:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "31303030303030",
+                                                "id": 7125,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2586:7:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                "value": "1000000"
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7128,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "2603:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7127,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2595:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7126,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2595:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7129,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2595:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7132,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "2618:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7131,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2610:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7130,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2610:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7133,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2610:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000_by_1",
+                                                    "typeString": "int_const 1000000"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7122,
+                                                "name": "skewVault",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6943,
+                                                "src": "2567:9:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_SkewVault_$1326",
+                                                    "typeString": "contract SkewVault"
+                                                }
+                                            },
+                                            "id": 7124,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "withdraw",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6005,
+                                            "src": "2567:18:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$_t_address_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (uint256,address,address) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7134,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2567:57:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7135,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2567:57:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 7147,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "id": 7143,
+                                                                    "name": "longFarmer",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 6940,
+                                                                    "src": "2709:10:19",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                        "typeString": "contract LongFarmer"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                                        "typeString": "contract LongFarmer"
+                                                                    }
+                                                                ],
+                                                                "id": 7142,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "2701:7:19",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_address_$",
+                                                                    "typeString": "type(address)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 7141,
+                                                                    "name": "address",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "2701:7:19",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 7144,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "2701:19:19",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                                    "id": 7138,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "2647:42:19",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    },
+                                                                    "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                ],
+                                                                "id": 7137,
+                                                                "name": "ERC20",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4639,
+                                                                "src": "2641:5:19",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_contract$_ERC20_$4639_$",
+                                                                    "typeString": "type(contract ERC20)"
+                                                                }
+                                                            },
+                                                            "id": 7139,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "2641:49:19",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_ERC20_$4639",
+                                                                "typeString": "contract ERC20"
+                                                            }
+                                                        },
+                                                        "id": 7140,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "balanceOf",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 4152,
+                                                        "src": "2641:59:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_view$_t_address_$returns$_t_uint256_$",
+                                                            "typeString": "function (address) view external returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 7145,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "2641:80:19",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "==",
+                                                "rightExpression": {
+                                                    "hexValue": "30",
+                                                    "id": 7146,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "2725:1:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_0_by_1",
+                                                        "typeString": "int_const 0"
+                                                    },
+                                                    "value": "0"
+                                                },
+                                                "src": "2641:85:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 7136,
+                                            "name": "assert",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": -3,
+                                            "src": "2634:6:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_assert_pure$_t_bool_$returns$__$",
+                                                "typeString": "function (bool) pure"
+                                            }
+                                        },
+                                        "id": 7148,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2634:93:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7149,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2634:93:19"
+                                }
+                            ]
+                        },
+                        "functionSelector": "d509b16c",
+                        "id": 7151,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "testWithdraw",
+                        "nameLocation": "2484:12:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 7110,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2496:2:19"
+                        },
+                        "returnParameters": {
+                            "id": 7111,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2506:0:19"
+                        },
+                        "scope": 7276,
+                        "src": "2475:259:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 7213,
+                            "nodeType": "Block",
+                            "src": "2771:372:19",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 7161,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "id": 7154,
+                                            "name": "longT",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 6949,
+                                            "src": "2781:5:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                "typeString": "contract FakeERC20"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "307834416144633438303837623536396444334536356442653635423064443033363839313736376533",
+                                                            "id": 7158,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "2810:42:19",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            },
+                                                            "value": "0x4AaDc48087b569dD3E65dBe65B0dD036891767e3"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        ],
+                                                        "id": 7157,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "2802:7:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_address_$",
+                                                            "typeString": "type(address)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 7156,
+                                                            "name": "address",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "2802:7:19",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    },
+                                                    "id": 7159,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "typeConversion",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "2802:51:19",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                ],
+                                                "id": 7155,
+                                                "name": "fakeOutERC20",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 7486,
+                                                "src": "2789:12:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_address_$returns$_t_contract$_FakeERC20_$8238_$",
+                                                    "typeString": "function (address) returns (contract FakeERC20)"
+                                                }
+                                            },
+                                            "id": 7160,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "2789:65:19",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                "typeString": "contract FakeERC20"
+                                            }
+                                        },
+                                        "src": "2781:73:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                            "typeString": "contract FakeERC20"
+                                        }
+                                    },
+                                    "id": 7162,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2781:73:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7168,
+                                                        "name": "this",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -28,
+                                                        "src": "2890:4:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_SkewVaulttest_$7276",
+                                                            "typeString": "contract SkewVaulttest"
+                                                        }
+                                                    ],
+                                                    "id": 7167,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2882:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7166,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2882:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7169,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2882:13:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7170,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2897:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7163,
+                                                "name": "longT",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6949,
+                                                "src": "2864:5:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7165,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "_setBalance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7786,
+                                            "src": "2864:17:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_uint256_$",
+                                                "typeString": "function (address,uint256) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7171,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2864:38:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7172,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2864:38:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7178,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "2937:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7177,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "2929:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7176,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "2929:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7179,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2929:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7180,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2950:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7173,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "2912:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7175,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "_setBalance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7786,
+                                            "src": "2912:16:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_uint256_$",
+                                                "typeString": "function (address,uint256) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7181,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2912:43:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7182,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2912:43:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [],
+                                        "expression": {
+                                            "argumentTypes": [],
+                                            "expression": {
+                                                "id": 7183,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "2965:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7185,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "setActive",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1020,
+                                            "src": "2965:20:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$__$returns$__$",
+                                                "typeString": "function () external"
+                                            }
+                                        },
+                                        "id": 7186,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2965:22:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7187,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2965:22:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7193,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "3019:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7192,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "3011:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7191,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "3011:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7194,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3011:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7195,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3032:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7188,
+                                                "name": "longT",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6949,
+                                                "src": "2997:5:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7190,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "2997:13:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7196,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2997:40:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7197,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2997:40:19"
+                                },
+                                {
+                                    "assignments": [7199],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 7199,
+                                            "mutability": "mutable",
+                                            "name": "want",
+                                            "nameLocation": "3055:4:19",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 7213,
+                                            "src": "3047:12:19",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 7198,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "3047:7:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 7201,
+                                    "initialValue": {
+                                        "hexValue": "3130303030303030",
+                                        "id": 7200,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": true,
+                                        "kind": "number",
+                                        "lValueRequested": false,
+                                        "nodeType": "Literal",
+                                        "src": "3062:8:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_rational_10000000_by_1",
+                                            "typeString": "int_const 10000000"
+                                        },
+                                        "value": "10000000"
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "3047:23:19"
+                                },
+                                {
+                                    "assignments": [7203],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 7203,
+                                            "mutability": "mutable",
+                                            "name": "_lP",
+                                            "nameLocation": "3088:3:19",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 7213,
+                                            "src": "3080:11:19",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 7202,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "3080:7:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 7205,
+                                    "initialValue": {
+                                        "hexValue": "31",
+                                        "id": 7204,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": true,
+                                        "kind": "number",
+                                        "lValueRequested": false,
+                                        "nodeType": "Literal",
+                                        "src": "3094:1:19",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_rational_1_by_1",
+                                            "typeString": "int_const 1"
+                                        },
+                                        "value": "1"
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "3080:15:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "3130303030303030",
+                                                "id": 7209,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3122:8:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_10000000_by_1",
+                                                    "typeString": "int_const 10000000"
+                                                },
+                                                "value": "10000000"
+                                            },
+                                            {
+                                                "id": 7210,
+                                                "name": "_lP",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 7203,
+                                                "src": "3132:3:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_rational_10000000_by_1",
+                                                    "typeString": "int_const 10000000"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7206,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "3105:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7208,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "_swap",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 964,
+                                            "src": "3105:16:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$_t_uint256_$returns$_t_uint256_$",
+                                                "typeString": "function (uint256,uint256) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7211,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3105:31:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7212,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3105:31:19"
+                                }
+                            ]
+                        },
+                        "functionSelector": "ac2e92cb",
+                        "id": 7214,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "testLongSwap",
+                        "nameLocation": "2749:12:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 7152,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2761:2:19"
+                        },
+                        "returnParameters": {
+                            "id": 7153,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2771:0:19"
+                        },
+                        "scope": 7276,
+                        "src": "2740:403:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 7274,
+                            "nodeType": "Block",
+                            "src": "3178:1331:19",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7222,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "3213:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7221,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "3205:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7220,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "3205:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7223,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3205:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7224,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3226:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7217,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "3188:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7219,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "_setBalance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7786,
+                                            "src": "3188:16:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_uint256_$",
+                                                "typeString": "function (address,uint256) external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7225,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3188:43:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7226,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3188:43:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "307863634330333530433230394636463031443037316333636463323065456235454534413733643830",
+                                                "id": 7230,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3268:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0xccC0350C209F6F01D071c3cdc20eEb5EE4A73d80"
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7231,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3312:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7227,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "3255:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7229,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "3255:12:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7232,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3255:62:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7233,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3255:62:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "307843336432303532343739644243303130343830416531363230343737374331343639434566664339",
+                                                "id": 7237,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3341:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0xC3d2052479dBC010480Ae16204777C1469CEffC9"
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7238,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3385:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7234,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "3328:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7236,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "3328:12:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7239,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3328:62:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7240,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3328:62:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "307838313535613735386130364537653338353139314331313944333531393541613734336342653966",
+                                                "id": 7244,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3413:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0x8155a758a06E7e385191C119D35195Aa743cBe9f"
+                                            },
+                                            {
+                                                "hexValue": "31653138",
+                                                "id": 7245,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3457:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                },
+                                                "value": "1e18"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                    "typeString": "int_const 1000000000000000000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7241,
+                                                "name": "fUSD",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6946,
+                                                "src": "3400:4:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_FakeERC20_$8238",
+                                                    "typeString": "contract FakeERC20"
+                                                }
+                                            },
+                                            "id": 7243,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "approve",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 7749,
+                                            "src": "3400:12:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$_t_bool_$",
+                                                "typeString": "function (address,uint256) external returns (bool)"
+                                            }
+                                        },
+                                        "id": 7246,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3400:62:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 7247,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3400:62:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 7254,
+                                                        "name": "longFarmer",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 6940,
+                                                        "src": "3540:10:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                            "typeString": "contract LongFarmer"
+                                                        }
+                                                    ],
+                                                    "id": 7253,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "3532:7:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 7252,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "3532:7:19",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 7255,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3532:19:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "307838313535613735386130364537653338353139314331313944333531393541613734336342653966",
+                                                "id": 7256,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3553:42:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                "value": "0x8155a758a06E7e385191C119D35195Aa743cBe9f"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "307839653036326565653263304162393665314531633863453338624631346241336661306133354636",
+                                                        "id": 7249,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "3478:42:19",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        },
+                                                        "value": "0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6"
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 7248,
+                                                    "name": "ERC20",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4639,
+                                                    "src": "3472:5:19",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_contract$_ERC20_$4639_$",
+                                                        "typeString": "type(contract ERC20)"
+                                                    }
+                                                },
+                                                "id": 7250,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3472:49:19",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_ERC20_$4639",
+                                                    "typeString": "contract ERC20"
+                                                }
+                                            },
+                                            "id": 7251,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "allowance",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 4195,
+                                            "src": "3472:59:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_view$_t_address_$_t_address_$returns$_t_uint256_$",
+                                                "typeString": "function (address,address) view external returns (uint256)"
+                                            }
+                                        },
+                                        "id": 7257,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3472:124:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 7258,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3472:124:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [],
+                                        "expression": {
+                                            "argumentTypes": [],
+                                            "expression": {
+                                                "id": 7259,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "3606:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7261,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "setActive",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 1020,
+                                            "src": "3606:20:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$__$returns$__$",
+                                                "typeString": "function () external"
+                                            }
+                                        },
+                                        "id": 7262,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3606:22:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7263,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3606:22:19"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "3130303030",
+                                                "id": 7267,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3657:5:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_10000_by_1",
+                                                    "typeString": "int_const 10000"
+                                                },
+                                                "value": "10000"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_rational_10000_by_1",
+                                                    "typeString": "int_const 10000"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 7264,
+                                                "name": "longFarmer",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 6940,
+                                                "src": "3638:10:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_LongFarmer_$1134",
+                                                    "typeString": "contract LongFarmer"
+                                                }
+                                            },
+                                            "id": 7266,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "acquire",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 776,
+                                            "src": "3638:18:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$returns$__$",
+                                                "typeString": "function (uint256) external"
+                                            }
+                                        },
+                                        "id": 7268,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3638:25:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7269,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3638:25:19"
+                                },
+                                {
+                                    "eventCall": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "636f6d6d6974",
+                                                "id": 7271,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "3682:8:19",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_a97dd2cbe677d6dda22dd4a01edec54ba307cd2b1f7d130707ba5a29cc019c1d",
+                                                    "typeString": "literal_string \"commit\""
+                                                },
+                                                "value": "commit"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_a97dd2cbe677d6dda22dd4a01edec54ba307cd2b1f7d130707ba5a29cc019c1d",
+                                                    "typeString": "literal_string \"commit\""
+                                                }
+                                            ],
+                                            "id": 7270,
+                                            "name": "Log",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 6956,
+                                            "src": "3678:3:19",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (string memory)"
+                                            }
+                                        },
+                                        "id": 7272,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3678:13:19",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 7273,
+                                    "nodeType": "EmitStatement",
+                                    "src": "3673:18:19"
+                                }
+                            ]
+                        },
+                        "functionSelector": "e98a7f3a",
+                        "id": 7275,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "testCommit",
+                        "nameLocation": "3158:10:19",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 7215,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3168:2:19"
+                        },
+                        "returnParameters": {
+                            "id": 7216,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3178:0:19"
+                        },
+                        "scope": 7276,
+                        "src": "3149:1360:19",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    }
+                ],
+                "scope": 7277,
+                "src": "809:3702:19",
+                "usedErrors": []
+            }
+        ],
+        "src": "39:4473:19"
+    }
+}
diff --git a/out/Test.sol/Test.json b/out/Test.sol/Test.json
new file mode 100644
index 0000000..5761dd8
--- /dev/null
+++ b/out/Test.sol/Test.json
@@ -0,0 +1,29291 @@
+{
+    "abi": [
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "msg",
+                    "type": "string"
+                }
+            ],
+            "name": "WARNING_Deprecated",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "name": "log",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "log_address",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "name": "log_bytes",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "bytes32",
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "log_bytes32",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "int256",
+                    "name": "",
+                    "type": "int256"
+                }
+            ],
+            "name": "log_int",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "address",
+                    "name": "val",
+                    "type": "address"
+                }
+            ],
+            "name": "log_named_address",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "bytes",
+                    "name": "val",
+                    "type": "bytes"
+                }
+            ],
+            "name": "log_named_bytes",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "bytes32",
+                    "name": "val",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "log_named_bytes32",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "int256",
+                    "name": "val",
+                    "type": "int256"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "decimals",
+                    "type": "uint256"
+                }
+            ],
+            "name": "log_named_decimal_int",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "val",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "decimals",
+                    "type": "uint256"
+                }
+            ],
+            "name": "log_named_decimal_uint",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "int256",
+                    "name": "val",
+                    "type": "int256"
+                }
+            ],
+            "name": "log_named_int",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "val",
+                    "type": "string"
+                }
+            ],
+            "name": "log_named_string",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "key",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "val",
+                    "type": "uint256"
+                }
+            ],
+            "name": "log_named_uint",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "name": "log_string",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "log_uint",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "name": "logs",
+            "type": "event"
+        },
+        {
+            "inputs": [],
+            "name": "IS_TEST",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "token",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "to",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "give",
+                    "type": "uint256"
+                }
+            ],
+            "name": "deal",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "token",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "to",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "give",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "bool",
+                    "name": "adjust",
+                    "type": "bool"
+                }
+            ],
+            "name": "deal",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "to",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "give",
+                    "type": "uint256"
+                }
+            ],
+            "name": "deal",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "string",
+                    "name": "what",
+                    "type": "string"
+                },
+                {
+                    "internalType": "bytes",
+                    "name": "args",
+                    "type": "bytes"
+                }
+            ],
+            "name": "deployCode",
+            "outputs": [
+                {
+                    "internalType": "address",
+                    "name": "addr",
+                    "type": "address"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "string",
+                    "name": "what",
+                    "type": "string"
+                }
+            ],
+            "name": "deployCode",
+            "outputs": [
+                {
+                    "internalType": "address",
+                    "name": "addr",
+                    "type": "address"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "failed",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "who",
+                    "type": "address"
+                }
+            ],
+            "name": "hoax",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "who",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "origin",
+                    "type": "address"
+                }
+            ],
+            "name": "hoax",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "who",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "origin",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "give",
+                    "type": "uint256"
+                }
+            ],
+            "name": "hoax",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "who",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "give",
+                    "type": "uint256"
+                }
+            ],
+            "name": "hoax",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "time",
+                    "type": "uint256"
+                }
+            ],
+            "name": "rewind",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "time",
+                    "type": "uint256"
+                }
+            ],
+            "name": "skip",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "who",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "give",
+                    "type": "uint256"
+                }
+            ],
+            "name": "startHoax",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "who",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "origin",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "give",
+                    "type": "uint256"
+                }
+            ],
+            "name": "startHoax",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "who",
+                    "type": "address"
+                }
+            ],
+            "name": "startHoax",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "who",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "origin",
+                    "type": "address"
+                }
+            ],
+            "name": "startHoax",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "token",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "to",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "give",
+                    "type": "uint256"
+                }
+            ],
+            "name": "tip",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "vm",
+            "outputs": [
+                {
+                    "internalType": "contract Vm",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        }
+    ],
+    "bytecode": {
+        "object": "0x",
+        "sourceMap": "",
+        "linkReferences": {}
+    },
+    "deployedBytecode": {
+        "object": "0x",
+        "sourceMap": "",
+        "linkReferences": {}
+    },
+    "ast": {
+        "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/Test.sol",
+        "exportedSymbols": {
+            "DSTest": [3806],
+            "StdStorage": [5033],
+            "Test": [4935],
+            "Vm": [6200],
+            "console": [14264],
+            "console2": [22328],
+            "stdError": [5005],
+            "stdStorage": [5990]
+        },
+        "id": 5991,
+        "license": "Unlicense",
+        "nodeType": "SourceUnit",
+        "nodes": [
+            {
+                "id": 3808,
+                "literals": ["solidity", ">=", "0.6", ".0", "<", "0.9", ".0"],
+                "nodeType": "PragmaDirective",
+                "src": "38:31:6"
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/Vm.sol",
+                "file": "./Vm.sol",
+                "id": 3809,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 6201,
+                "src": "71:18:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/lib/ds-test/src/test.sol",
+                "file": "../lib/ds-test/src/test.sol",
+                "id": 3810,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 3807,
+                "src": "90:37:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/console.sol",
+                "file": "./console.sol",
+                "id": 3811,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 14265,
+                "src": "128:23:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/console2.sol",
+                "file": "./console2.sol",
+                "id": 3812,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 22329,
+                "src": "152:24:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "abstract": true,
+                "baseContracts": [
+                    {
+                        "baseName": {
+                            "id": 3813,
+                            "name": "DSTest",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 3806,
+                            "src": "252:6:6"
+                        },
+                        "id": 3814,
+                        "nodeType": "InheritanceSpecifier",
+                        "src": "252:6:6"
+                    }
+                ],
+                "canonicalName": "Test",
+                "contractDependencies": [],
+                "contractKind": "contract",
+                "fullyImplemented": true,
+                "id": 4935,
+                "linearizedBaseContracts": [4935, 3806],
+                "name": "Test",
+                "nameLocation": "244:4:6",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "id": 3818,
+                        "libraryName": {
+                            "id": 3815,
+                            "name": "stdStorage",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 5990,
+                            "src": "271:10:6"
+                        },
+                        "nodeType": "UsingForDirective",
+                        "src": "265:32:6",
+                        "typeName": {
+                            "id": 3817,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 3816,
+                                "name": "StdStorage",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 5033,
+                                "src": "286:10:6"
+                            },
+                            "referencedDeclaration": 5033,
+                            "src": "286:10:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                "typeString": "struct StdStorage"
+                            }
+                        }
+                    },
+                    {
+                        "anonymous": false,
+                        "id": 3822,
+                        "name": "WARNING_Deprecated",
+                        "nameLocation": "309:18:6",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 3821,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3820,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "msg",
+                                    "nameLocation": "335:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3822,
+                                    "src": "328:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 3819,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "328:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "327:12:6"
+                        },
+                        "src": "303:37:6"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "3a768463",
+                        "id": 3828,
+                        "mutability": "constant",
+                        "name": "vm",
+                        "nameLocation": "365:2:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 4935,
+                        "src": "346:40:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_Vm_$6200",
+                            "typeString": "contract Vm"
+                        },
+                        "typeName": {
+                            "id": 3824,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 3823,
+                                "name": "Vm",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6200,
+                                "src": "346:2:6"
+                            },
+                            "referencedDeclaration": 6200,
+                            "src": "346:2:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "id": 3826,
+                                    "name": "HEVM_ADDRESS",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": 2127,
+                                    "src": "373:12:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                ],
+                                "id": 3825,
+                                "name": "Vm",
+                                "nodeType": "Identifier",
+                                "overloadedDeclarations": [],
+                                "referencedDeclaration": 6200,
+                                "src": "370:2:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_contract$_Vm_$6200_$",
+                                    "typeString": "type(contract Vm)"
+                                }
+                            },
+                            "id": 3827,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "370:16:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": false,
+                        "id": 3831,
+                        "mutability": "mutable",
+                        "name": "stdstore",
+                        "nameLocation": "412:8:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 4935,
+                        "src": "392:28:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                            "typeString": "struct StdStorage"
+                        },
+                        "typeName": {
+                            "id": 3830,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 3829,
+                                "name": "StdStorage",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 5033,
+                                "src": "392:10:6"
+                            },
+                            "referencedDeclaration": 5033,
+                            "src": "392:10:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                "typeString": "struct StdStorage"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 3845,
+                            "nodeType": "Block",
+                            "src": "743:48:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 3842,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 3839,
+                                                        "name": "block",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -4,
+                                                        "src": "761:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_magic_block",
+                                                            "typeString": "block"
+                                                        }
+                                                    },
+                                                    "id": 3840,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "timestamp",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "761:15:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "+",
+                                                "rightExpression": {
+                                                    "id": 3841,
+                                                    "name": "time",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 3833,
+                                                    "src": "779:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "761:22:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3836,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "753:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3838,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "warp",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5998,
+                                            "src": "753:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$returns$__$",
+                                                "typeString": "function (uint256) external"
+                                            }
+                                        },
+                                        "id": 3843,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "753:31:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3844,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "753:31:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "b9c071b4",
+                        "id": 3846,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "skip",
+                        "nameLocation": "717:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3834,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3833,
+                                    "mutability": "mutable",
+                                    "name": "time",
+                                    "nameLocation": "730:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3846,
+                                    "src": "722:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3832,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "722:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "721:14:6"
+                        },
+                        "returnParameters": {
+                            "id": 3835,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "743:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "708:83:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3860,
+                            "nodeType": "Block",
+                            "src": "834:48:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 3857,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 3854,
+                                                        "name": "block",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -4,
+                                                        "src": "852:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_magic_block",
+                                                            "typeString": "block"
+                                                        }
+                                                    },
+                                                    "id": 3855,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "timestamp",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "852:15:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "-",
+                                                "rightExpression": {
+                                                    "id": 3856,
+                                                    "name": "time",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 3848,
+                                                    "src": "870:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "852:22:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3851,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "844:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3853,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "warp",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5998,
+                                            "src": "844:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$returns$__$",
+                                                "typeString": "function (uint256) external"
+                                            }
+                                        },
+                                        "id": 3858,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "844:31:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3859,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "844:31:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "2d6c17a3",
+                        "id": 3861,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "rewind",
+                        "nameLocation": "806:6:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3849,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3848,
+                                    "mutability": "mutable",
+                                    "name": "time",
+                                    "nameLocation": "821:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3861,
+                                    "src": "813:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3847,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "813:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "812:14:6"
+                        },
+                        "returnParameters": {
+                            "id": 3850,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "834:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "797:85:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3881,
+                            "nodeType": "Block",
+                            "src": "979:62:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3869,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3863,
+                                                "src": "997:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 3872,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 3870,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1002:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 3871,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1007:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1002:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3866,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "989:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3868,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "989:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3873,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "989:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3874,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "989:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3878,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3863,
+                                                "src": "1030:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3875,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1021:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3877,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6078,
+                                            "src": "1021:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3879,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1021:13:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3880,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1021:13:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "233240ee",
+                        "id": 3882,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "954:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3864,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3863,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "967:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3882,
+                                    "src": "959:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3862,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "959:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "958:13:6"
+                        },
+                        "returnParameters": {
+                            "id": 3865,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "979:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "945:96:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3902,
+                            "nodeType": "Block",
+                            "src": "1095:58:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3892,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3884,
+                                                "src": "1113:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3893,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3886,
+                                                "src": "1118:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3889,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1105:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3891,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1105:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3894,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1105:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3895,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1105:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3899,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3884,
+                                                "src": "1142:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3896,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1133:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3898,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6078,
+                                            "src": "1133:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3900,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1133:13:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3901,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1133:13:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "e9a79a7b",
+                        "id": 3903,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "1056:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3887,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3884,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1069:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3903,
+                                    "src": "1061:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3883,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1061:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3886,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "1082:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3903,
+                                    "src": "1074:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3885,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1074:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1060:27:6"
+                        },
+                        "returnParameters": {
+                            "id": 3888,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1095:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1047:106:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3926,
+                            "nodeType": "Block",
+                            "src": "1209:70:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3913,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3905,
+                                                "src": "1227:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 3916,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 3914,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1232:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 3915,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1237:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1232:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3910,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1219:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3912,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1219:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3917,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1219:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3918,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1219:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3922,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3905,
+                                                "src": "1260:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3923,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3907,
+                                                "src": "1265:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3919,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1251:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3921,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6090,
+                                            "src": "1251:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 3924,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1251:21:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3925,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1251:21:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "29a9e300",
+                        "id": 3927,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "1168:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3908,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3905,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1181:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3927,
+                                    "src": "1173:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3904,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1173:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3907,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "1194:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3927,
+                                    "src": "1186:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3906,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1186:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1172:29:6"
+                        },
+                        "returnParameters": {
+                            "id": 3909,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1209:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1159:120:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3950,
+                            "nodeType": "Block",
+                            "src": "1349:66:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3939,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3929,
+                                                "src": "1367:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3940,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3933,
+                                                "src": "1372:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3936,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1359:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3938,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1359:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3941,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1359:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3942,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1359:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3946,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3929,
+                                                "src": "1396:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3947,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3931,
+                                                "src": "1401:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3943,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1387:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3945,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6090,
+                                            "src": "1387:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 3948,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1387:21:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3949,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1387:21:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "af9bbe5f",
+                        "id": 3951,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "1294:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3934,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3929,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1307:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3951,
+                                    "src": "1299:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3928,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1299:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3931,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "1320:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3951,
+                                    "src": "1312:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3930,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1312:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3933,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "1336:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3951,
+                                    "src": "1328:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3932,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1328:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1298:43:6"
+                        },
+                        "returnParameters": {
+                            "id": 3935,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1349:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1285:130:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3971,
+                            "nodeType": "Block",
+                            "src": "1525:67:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3959,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3953,
+                                                "src": "1543:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 3962,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 3960,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1548:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 3961,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1553:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1548:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3956,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1535:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3958,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1535:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3963,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1535:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3964,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1535:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3968,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3953,
+                                                "src": "1581:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3965,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1567:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3967,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6083,
+                                            "src": "1567:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3969,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1567:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3970,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1567:18:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "6f597075",
+                        "id": 3972,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1495:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3954,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3953,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1513:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3972,
+                                    "src": "1505:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3952,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1505:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1504:13:6"
+                        },
+                        "returnParameters": {
+                            "id": 3955,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1525:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1486:106:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3992,
+                            "nodeType": "Block",
+                            "src": "1651:63:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3982,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3974,
+                                                "src": "1669:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3983,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3976,
+                                                "src": "1674:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3979,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1661:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3981,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1661:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3984,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1661:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3985,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1661:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3989,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3974,
+                                                "src": "1703:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3986,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1689:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3988,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6083,
+                                            "src": "1689:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3990,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1689:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3991,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1689:18:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "108554f2",
+                        "id": 3993,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1607:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3977,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3974,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1625:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3993,
+                                    "src": "1617:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3973,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1617:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3976,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "1638:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3993,
+                                    "src": "1630:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3975,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1630:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1616:27:6"
+                        },
+                        "returnParameters": {
+                            "id": 3978,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1651:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1598:116:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4016,
+                            "nodeType": "Block",
+                            "src": "1888:75:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4003,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3995,
+                                                "src": "1906:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 4006,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 4004,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1911:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 4005,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1916:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1911:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4000,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1898:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4002,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1898:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 4007,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1898:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4008,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1898:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4012,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3995,
+                                                "src": "1944:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4013,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3997,
+                                                "src": "1949:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4009,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1930:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4011,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6097,
+                                            "src": "1930:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 4014,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1930:26:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4015,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1930:26:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "d06d8229",
+                        "id": 4017,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1842:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3998,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3995,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1860:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4017,
+                                    "src": "1852:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3994,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1852:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3997,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "1873:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4017,
+                                    "src": "1865:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3996,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1865:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1851:29:6"
+                        },
+                        "returnParameters": {
+                            "id": 3999,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1888:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1833:130:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4040,
+                            "nodeType": "Block",
+                            "src": "2038:71:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4029,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4019,
+                                                "src": "2056:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4030,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4023,
+                                                "src": "2061:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4026,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "2048:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4028,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "2048:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 4031,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2048:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4032,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2048:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4036,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4019,
+                                                "src": "2090:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4037,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4021,
+                                                "src": "2095:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4033,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "2076:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4035,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6097,
+                                            "src": "2076:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 4038,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2076:26:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4039,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2076:26:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "3bf82db1",
+                        "id": 4041,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1978:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4024,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4019,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1996:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4041,
+                                    "src": "1988:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4018,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1988:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4021,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "2009:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4041,
+                                    "src": "2001:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4020,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2001:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4023,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2025:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4041,
+                                    "src": "2017:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4022,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2017:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1987:43:6"
+                        },
+                        "returnParameters": {
+                            "id": 4025,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2038:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1969:140:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4069,
+                            "nodeType": "Block",
+                            "src": "2214:236:6",
+                            "statements": [
+                                {
+                                    "eventCall": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "54686520607469706020737464636865617420686173206265656e20646570726563617465642e2055736520606465616c6020696e73746561642e",
+                                                "id": 4051,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2248:61:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_744a6c098d7a732288220a904d49fcc88d2e3ed1ffdf88ffc87b900c86d281d4",
+                                                    "typeString": "literal_string \"The `tip` stdcheat has been deprecated. Use `deal` instead.\""
+                                                },
+                                                "value": "The `tip` stdcheat has been deprecated. Use `deal` instead."
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_744a6c098d7a732288220a904d49fcc88d2e3ed1ffdf88ffc87b900c86d281d4",
+                                                    "typeString": "literal_string \"The `tip` stdcheat has been deprecated. Use `deal` instead.\""
+                                                }
+                                            ],
+                                            "id": 4050,
+                                            "name": "WARNING_Deprecated",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 3822,
+                                            "src": "2229:18:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (string memory)"
+                                            }
+                                        },
+                                        "id": 4052,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2229:81:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4053,
+                                    "nodeType": "EmitStatement",
+                                    "src": "2224:86:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4066,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4047,
+                                                "src": "2438:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 4063,
+                                                        "name": "to",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4045,
+                                                        "src": "2407:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "30783730613038323331",
+                                                                "id": 4060,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "2373:10:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                },
+                                                                "value": "0x70a08231"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 4057,
+                                                                        "name": "token",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4043,
+                                                                        "src": "2349:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "id": 4054,
+                                                                        "name": "stdstore",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 3831,
+                                                                        "src": "2320:8:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                                                                            "typeString": "struct StdStorage storage ref"
+                                                                        }
+                                                                    },
+                                                                    "id": 4056,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "target",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5549,
+                                                                    "src": "2320:28:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                                    }
+                                                                },
+                                                                "id": 4058,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "2320:35:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 4059,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "sig",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5569,
+                                                            "src": "2320:52:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes4_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                "typeString": "function (struct StdStorage storage pointer,bytes4) returns (struct StdStorage storage pointer)"
+                                                            }
+                                                        },
+                                                        "id": 4061,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "2320:64:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 4062,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "with_key",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5622,
+                                                    "src": "2320:86:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                    }
+                                                },
+                                                "id": 4064,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2320:90:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 4065,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "checked_write",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5729,
+                                            "src": "2320:117:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_uint256_$returns$__$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                "typeString": "function (struct StdStorage storage pointer,uint256)"
+                                            }
+                                        },
+                                        "id": 4067,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2320:123:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4068,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2320:123:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "d82555f1",
+                        "id": 4070,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "tip",
+                        "nameLocation": "2162:3:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4048,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4043,
+                                    "mutability": "mutable",
+                                    "name": "token",
+                                    "nameLocation": "2174:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4070,
+                                    "src": "2166:13:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4042,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2166:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4045,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2189:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4070,
+                                    "src": "2181:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4044,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2181:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4047,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2201:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4070,
+                                    "src": "2193:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4046,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2193:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2165:41:6"
+                        },
+                        "returnParameters": {
+                            "id": 4049,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2214:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2153:297:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4084,
+                            "nodeType": "Block",
+                            "src": "2590:34:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4080,
+                                                "name": "to",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4072,
+                                                "src": "2608:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4081,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4074,
+                                                "src": "2612:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4077,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "2600:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4079,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "2600:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 4082,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2600:17:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4083,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2600:17:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "c88a5e6d",
+                        "id": 4085,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deal",
+                        "nameLocation": "2552:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4075,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4072,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2565:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4085,
+                                    "src": "2557:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4071,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2557:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4074,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2577:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4085,
+                                    "src": "2569:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4073,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2569:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2556:26:6"
+                        },
+                        "returnParameters": {
+                            "id": 4076,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2590:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2543:81:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4101,
+                            "nodeType": "Block",
+                            "src": "2810:45:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4095,
+                                                "name": "token",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4087,
+                                                "src": "2825:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4096,
+                                                "name": "to",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4089,
+                                                "src": "2832:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4097,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4091,
+                                                "src": "2836:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "66616c7365",
+                                                "id": 4098,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2842:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "false"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 4094,
+                                            "name": "deal",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                4085, 4102, 4205
+                                            ],
+                                            "referencedDeclaration": 4205,
+                                            "src": "2820:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$_t_bool_$returns$__$",
+                                                "typeString": "function (address,address,uint256,bool)"
+                                            }
+                                        },
+                                        "id": 4099,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2820:28:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4100,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2820:28:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "6bce989b",
+                        "id": 4102,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deal",
+                        "nameLocation": "2757:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4092,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4087,
+                                    "mutability": "mutable",
+                                    "name": "token",
+                                    "nameLocation": "2770:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4102,
+                                    "src": "2762:13:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4086,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2762:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4089,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2785:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4102,
+                                    "src": "2777:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4088,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2777:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4091,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2797:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4102,
+                                    "src": "2789:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4090,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2789:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2761:41:6"
+                        },
+                        "returnParameters": {
+                            "id": 4093,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2810:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2748:107:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4204,
+                            "nodeType": "Block",
+                            "src": "2936:840:6",
+                            "statements": [
+                                {
+                                    "assignments": [null, 4114],
+                                    "declarations": [
+                                        null,
+                                        {
+                                            "constant": false,
+                                            "id": 4114,
+                                            "mutability": "mutable",
+                                            "name": "balData",
+                                            "nameLocation": "2993:7:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4204,
+                                            "src": "2980:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 4113,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "2980:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4123,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "30783730613038323331",
+                                                        "id": 4119,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "3038:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1889567281_by_1",
+                                                            "typeString": "int_const 1889567281"
+                                                        },
+                                                        "value": "0x70a08231"
+                                                    },
+                                                    {
+                                                        "id": 4120,
+                                                        "name": "to",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4106,
+                                                        "src": "3050:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_rational_1889567281_by_1",
+                                                            "typeString": "int_const 1889567281"
+                                                        },
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 4117,
+                                                        "name": "abi",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -1,
+                                                        "src": "3015:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_magic_abi",
+                                                            "typeString": "abi"
+                                                        }
+                                                    },
+                                                    "id": 4118,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "memberName": "encodeWithSelector",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "3015:22:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_abiencodewithselector_pure$_t_bytes4_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes4) pure returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 4121,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3015:38:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4115,
+                                                "name": "token",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4104,
+                                                "src": "3004:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            "id": 4116,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "call",
+                                            "nodeType": "MemberAccess",
+                                            "src": "3004:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_barecall_payable$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                "typeString": "function (bytes memory) payable returns (bool,bytes memory)"
+                                            }
+                                        },
+                                        "id": 4122,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3004:50:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                            "typeString": "tuple(bool,bytes memory)"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "2977:77:6"
+                                },
+                                {
+                                    "assignments": [4125],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4125,
+                                            "mutability": "mutable",
+                                            "name": "prevBal",
+                                            "nameLocation": "3072:7:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4204,
+                                            "src": "3064:15:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4124,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "3064:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4133,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 4128,
+                                                "name": "balData",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4114,
+                                                "src": "3093:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            },
+                                            {
+                                                "components": [
+                                                    {
+                                                        "id": 4130,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "3103:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_uint256_$",
+                                                            "typeString": "type(uint256)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 4129,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "3103:7:6",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    }
+                                                ],
+                                                "id": 4131,
+                                                "isConstant": false,
+                                                "isInlineArray": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "nodeType": "TupleExpression",
+                                                "src": "3102:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_uint256_$",
+                                                    "typeString": "type(uint256)"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_type$_t_uint256_$",
+                                                    "typeString": "type(uint256)"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4126,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "3082:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 4127,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "decode",
+                                            "nodeType": "MemberAccess",
+                                            "src": "3082:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abidecode_pure$__$returns$__$",
+                                                "typeString": "function () pure"
+                                            }
+                                        },
+                                        "id": 4132,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3082:30:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "3064:48:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4146,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4108,
+                                                "src": "3267:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 4143,
+                                                        "name": "to",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4106,
+                                                        "src": "3236:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "30783730613038323331",
+                                                                "id": 4140,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "3202:10:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                },
+                                                                "value": "0x70a08231"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 4137,
+                                                                        "name": "token",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4104,
+                                                                        "src": "3178:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "id": 4134,
+                                                                        "name": "stdstore",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 3831,
+                                                                        "src": "3149:8:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                                                                            "typeString": "struct StdStorage storage ref"
+                                                                        }
+                                                                    },
+                                                                    "id": 4136,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "target",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5549,
+                                                                    "src": "3149:28:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                                    }
+                                                                },
+                                                                "id": 4138,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "3149:35:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 4139,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "sig",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5569,
+                                                            "src": "3149:52:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes4_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                "typeString": "function (struct StdStorage storage pointer,bytes4) returns (struct StdStorage storage pointer)"
+                                                            }
+                                                        },
+                                                        "id": 4141,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "3149:64:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 4142,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "with_key",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5622,
+                                                    "src": "3149:86:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                    }
+                                                },
+                                                "id": 4144,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3149:90:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 4145,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "checked_write",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5729,
+                                            "src": "3149:117:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_uint256_$returns$__$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                "typeString": "function (struct StdStorage storage pointer,uint256)"
+                                            }
+                                        },
+                                        "id": 4147,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3149:123:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4148,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3149:123:6"
+                                },
+                                {
+                                    "condition": {
+                                        "id": 4149,
+                                        "name": "adjust",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 4110,
+                                        "src": "3317:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4203,
+                                    "nodeType": "IfStatement",
+                                    "src": "3314:456:6",
+                                    "trueBody": {
+                                        "id": 4202,
+                                        "nodeType": "Block",
+                                        "src": "3324:446:6",
+                                        "statements": [
+                                            {
+                                                "assignments": [null, 4151],
+                                                "declarations": [
+                                                    null,
+                                                    {
+                                                        "constant": false,
+                                                        "id": 4151,
+                                                        "mutability": "mutable",
+                                                        "name": "totSupData",
+                                                        "nameLocation": "3354:10:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 4202,
+                                                        "src": "3341:23:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "memory",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 4150,
+                                                            "name": "bytes",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "3341:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_storage_ptr",
+                                                                "typeString": "bytes"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 4159,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "30783138313630646464",
+                                                                    "id": 4156,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "3402:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    },
+                                                                    "value": "0x18160ddd"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "id": 4154,
+                                                                    "name": "abi",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": -1,
+                                                                    "src": "3379:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_magic_abi",
+                                                                        "typeString": "abi"
+                                                                    }
+                                                                },
+                                                                "id": 4155,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "memberName": "encodeWithSelector",
+                                                                "nodeType": "MemberAccess",
+                                                                "src": "3379:22:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_abiencodewithselector_pure$_t_bytes4_$returns$_t_bytes_memory_ptr_$",
+                                                                    "typeString": "function (bytes4) pure returns (bytes memory)"
+                                                                }
+                                                            },
+                                                            "id": 4157,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "3379:34:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 4152,
+                                                            "name": "token",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4104,
+                                                            "src": "3368:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        "id": 4153,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "call",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "3368:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_barecall_payable$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                            "typeString": "function (bytes memory) payable returns (bool,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4158,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "3368:46:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                        "typeString": "tuple(bool,bytes memory)"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "3338:76:6"
+                                            },
+                                            {
+                                                "assignments": [4161],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 4161,
+                                                        "mutability": "mutable",
+                                                        "name": "totSup",
+                                                        "nameLocation": "3436:6:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 4202,
+                                                        "src": "3428:14:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 4160,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "3428:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 4169,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 4164,
+                                                            "name": "totSupData",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4151,
+                                                            "src": "3456:10:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "components": [
+                                                                {
+                                                                    "id": 4166,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                                    "src": "3469:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_type$_t_uint256_$",
+                                                                        "typeString": "type(uint256)"
+                                                                    },
+                                                                    "typeName": {
+                                                                        "id": 4165,
+                                                                        "name": "uint256",
+                                                                        "nodeType": "ElementaryTypeName",
+                                                                        "src": "3469:7:6",
+                                                                        "typeDescriptions": {}
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "id": 4167,
+                                                            "isConstant": false,
+                                                            "isInlineArray": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "TupleExpression",
+                                                            "src": "3468:9:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 4162,
+                                                            "name": "abi",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -1,
+                                                            "src": "3445:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_abi",
+                                                                "typeString": "abi"
+                                                            }
+                                                        },
+                                                        "id": 4163,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "memberName": "decode",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "3445:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_abidecode_pure$__$returns$__$",
+                                                            "typeString": "function () pure"
+                                                        }
+                                                    },
+                                                    "id": 4168,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "3445:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "3428:50:6"
+                                            },
+                                            {
+                                                "condition": {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    "id": 4172,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "id": 4170,
+                                                        "name": "give",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4108,
+                                                        "src": "3495:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "<",
+                                                    "rightExpression": {
+                                                        "id": 4171,
+                                                        "name": "prevBal",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4125,
+                                                        "src": "3502:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "3495:14:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "falseBody": {
+                                                    "id": 4188,
+                                                    "nodeType": "Block",
+                                                    "src": "3576:59:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "id": 4186,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "leftHandSide": {
+                                                                    "id": 4181,
+                                                                    "name": "totSup",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 4161,
+                                                                    "src": "3594:6:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "nodeType": "Assignment",
+                                                                "operator": "+=",
+                                                                "rightHandSide": {
+                                                                    "components": [
+                                                                        {
+                                                                            "commonType": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            },
+                                                                            "id": 4184,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftExpression": {
+                                                                                "id": 4182,
+                                                                                "name": "give",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4108,
+                                                                                "src": "3605:4:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "BinaryOperation",
+                                                                            "operator": "-",
+                                                                            "rightExpression": {
+                                                                                "id": 4183,
+                                                                                "name": "prevBal",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4125,
+                                                                                "src": "3612:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "src": "3605:14:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "id": 4185,
+                                                                    "isConstant": false,
+                                                                    "isInlineArray": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "TupleExpression",
+                                                                    "src": "3604:16:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "src": "3594:26:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "id": 4187,
+                                                            "nodeType": "ExpressionStatement",
+                                                            "src": "3594:26:6"
+                                                        }
+                                                    ]
+                                                },
+                                                "id": 4189,
+                                                "nodeType": "IfStatement",
+                                                "src": "3492:143:6",
+                                                "trueBody": {
+                                                    "id": 4180,
+                                                    "nodeType": "Block",
+                                                    "src": "3511:59:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "id": 4178,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "leftHandSide": {
+                                                                    "id": 4173,
+                                                                    "name": "totSup",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 4161,
+                                                                    "src": "3529:6:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "nodeType": "Assignment",
+                                                                "operator": "-=",
+                                                                "rightHandSide": {
+                                                                    "components": [
+                                                                        {
+                                                                            "commonType": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            },
+                                                                            "id": 4176,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftExpression": {
+                                                                                "id": 4174,
+                                                                                "name": "prevBal",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4125,
+                                                                                "src": "3540:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "BinaryOperation",
+                                                                            "operator": "-",
+                                                                            "rightExpression": {
+                                                                                "id": 4175,
+                                                                                "name": "give",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4108,
+                                                                                "src": "3550:4:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "src": "3540:14:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "id": 4177,
+                                                                    "isConstant": false,
+                                                                    "isInlineArray": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "TupleExpression",
+                                                                    "src": "3539:16:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "src": "3529:26:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "id": 4179,
+                                                            "nodeType": "ExpressionStatement",
+                                                            "src": "3529:26:6"
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 4199,
+                                                            "name": "totSup",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4161,
+                                                            "src": "3752:6:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "30783138313630646464",
+                                                                    "id": 4196,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "3709:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    },
+                                                                    "value": "0x18160ddd"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 4193,
+                                                                            "name": "token",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 4104,
+                                                                            "src": "3681:5:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 4190,
+                                                                            "name": "stdstore",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 3831,
+                                                                            "src": "3648:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                                                                                "typeString": "struct StdStorage storage ref"
+                                                                            }
+                                                                        },
+                                                                        "id": 4192,
+                                                                        "isConstant": false,
+                                                                        "isLValue": true,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "target",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 5549,
+                                                                        "src": "3648:32:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                            "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                                        }
+                                                                    },
+                                                                    "id": 4194,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "3648:39:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                    }
+                                                                },
+                                                                "id": 4195,
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "memberName": "sig",
+                                                                "nodeType": "MemberAccess",
+                                                                "referencedDeclaration": 5569,
+                                                                "src": "3648:60:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes4_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                    "typeString": "function (struct StdStorage storage pointer,bytes4) returns (struct StdStorage storage pointer)"
+                                                                }
+                                                            },
+                                                            "id": 4197,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "3648:72:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        },
+                                                        "id": 4198,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "checked_write",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 5729,
+                                                        "src": "3648:103:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_uint256_$returns$__$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                            "typeString": "function (struct StdStorage storage pointer,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4200,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "3648:111:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4201,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "3648:111:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "functionSelector": "97754ae9",
+                        "id": 4205,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deal",
+                        "nameLocation": "2870:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4111,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4104,
+                                    "mutability": "mutable",
+                                    "name": "token",
+                                    "nameLocation": "2883:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2875:13:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4103,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2875:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4106,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2898:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2890:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4105,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2890:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4108,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2910:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2902:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4107,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2902:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4110,
+                                    "mutability": "mutable",
+                                    "name": "adjust",
+                                    "nameLocation": "2921:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2916:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4109,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2916:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2874:54:6"
+                        },
+                        "returnParameters": {
+                            "id": 4112,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2936:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2861:915:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4226,
+                            "nodeType": "Block",
+                            "src": "4045:221:6",
+                            "statements": [
+                                {
+                                    "assignments": [4215],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4215,
+                                            "mutability": "mutable",
+                                            "name": "bytecode",
+                                            "nameLocation": "4068:8:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4226,
+                                            "src": "4055:21:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 4214,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "4055:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4224,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 4220,
+                                                        "name": "what",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4207,
+                                                        "src": "4107:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_string_memory_ptr",
+                                                            "typeString": "string memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_string_memory_ptr",
+                                                            "typeString": "string memory"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 4218,
+                                                        "name": "vm",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 3828,
+                                                        "src": "4096:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_Vm_$6200",
+                                                            "typeString": "contract Vm"
+                                                        }
+                                                    },
+                                                    "id": 4219,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "getCode",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 6187,
+                                                    "src": "4096:10:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_external_nonpayable$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (string memory) external returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 4221,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "4096:16:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            },
+                                            {
+                                                "id": 4222,
+                                                "name": "args",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4209,
+                                                "src": "4114:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4216,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "4079:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 4217,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "encodePacked",
+                                            "nodeType": "MemberAccess",
+                                            "src": "4079:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function () pure returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 4223,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4079:40:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "4055:64:6"
+                                },
+                                {
+                                    "AST": {
+                                        "nodeType": "YulBlock",
+                                        "src": "4181:79:6",
+                                        "statements": [
+                                            {
+                                                "nodeType": "YulAssignment",
+                                                "src": "4195:55:6",
+                                                "value": {
+                                                    "arguments": [
+                                                        {
+                                                            "kind": "number",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "4210:1:6",
+                                                            "type": "",
+                                                            "value": "0"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4217:8:6"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "4227:4:6",
+                                                                    "type": "",
+                                                                    "value": "0x20"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "add",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4213:3:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4213:19:6"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4240:8:6"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "mload",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4234:5:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4234:15:6"
+                                                        }
+                                                    ],
+                                                    "functionName": {
+                                                        "name": "create",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4203:6:6"
+                                                    },
+                                                    "nodeType": "YulFunctionCall",
+                                                    "src": "4203:47:6"
+                                                },
+                                                "variableNames": [
+                                                    {
+                                                        "name": "addr",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4195:4:6"
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    },
+                                    "documentation": "@solidity memory-safe-assembly",
+                                    "evmVersion": "london",
+                                    "externalReferences": [
+                                        {
+                                            "declaration": 4212,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4195:4:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4215,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4217:8:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4215,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4240:8:6",
+                                            "valueSize": 1
+                                        }
+                                    ],
+                                    "id": 4225,
+                                    "nodeType": "InlineAssembly",
+                                    "src": "4172:88:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "29ce9dde",
+                        "id": 4227,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deployCode",
+                        "nameLocation": "3945:10:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4210,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4207,
+                                    "mutability": "mutable",
+                                    "name": "what",
+                                    "nameLocation": "3970:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4227,
+                                    "src": "3956:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4206,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3956:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4209,
+                                    "mutability": "mutable",
+                                    "name": "args",
+                                    "nameLocation": "3989:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4227,
+                                    "src": "3976:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4208,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3976:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "3955:39:6"
+                        },
+                        "returnParameters": {
+                            "id": 4213,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4212,
+                                    "mutability": "mutable",
+                                    "name": "addr",
+                                    "nameLocation": "4035:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4227,
+                                    "src": "4027:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4211,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4027:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4026:14:6"
+                        },
+                        "scope": 4935,
+                        "src": "3936:330:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4242,
+                            "nodeType": "Block",
+                            "src": "4362:197:6",
+                            "statements": [
+                                {
+                                    "assignments": [4235],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4235,
+                                            "mutability": "mutable",
+                                            "name": "bytecode",
+                                            "nameLocation": "4385:8:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4242,
+                                            "src": "4372:21:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 4234,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "4372:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4240,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 4238,
+                                                "name": "what",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4229,
+                                                "src": "4407:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4236,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "4396:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4237,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "getCode",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6187,
+                                            "src": "4396:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function (string memory) external returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 4239,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4396:16:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "4372:40:6"
+                                },
+                                {
+                                    "AST": {
+                                        "nodeType": "YulBlock",
+                                        "src": "4474:79:6",
+                                        "statements": [
+                                            {
+                                                "nodeType": "YulAssignment",
+                                                "src": "4488:55:6",
+                                                "value": {
+                                                    "arguments": [
+                                                        {
+                                                            "kind": "number",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "4503:1:6",
+                                                            "type": "",
+                                                            "value": "0"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4510:8:6"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "4520:4:6",
+                                                                    "type": "",
+                                                                    "value": "0x20"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "add",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4506:3:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4506:19:6"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4533:8:6"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "mload",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4527:5:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4527:15:6"
+                                                        }
+                                                    ],
+                                                    "functionName": {
+                                                        "name": "create",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4496:6:6"
+                                                    },
+                                                    "nodeType": "YulFunctionCall",
+                                                    "src": "4496:47:6"
+                                                },
+                                                "variableNames": [
+                                                    {
+                                                        "name": "addr",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4488:4:6"
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    },
+                                    "documentation": "@solidity memory-safe-assembly",
+                                    "evmVersion": "london",
+                                    "externalReferences": [
+                                        {
+                                            "declaration": 4232,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4488:4:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4235,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4510:8:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4235,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4533:8:6",
+                                            "valueSize": 1
+                                        }
+                                    ],
+                                    "id": 4241,
+                                    "nodeType": "InlineAssembly",
+                                    "src": "4465:88:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "9a8325a0",
+                        "id": 4243,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deployCode",
+                        "nameLocation": "4281:10:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4230,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4229,
+                                    "mutability": "mutable",
+                                    "name": "what",
+                                    "nameLocation": "4306:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4243,
+                                    "src": "4292:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4228,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4292:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4291:20:6"
+                        },
+                        "returnParameters": {
+                            "id": 4233,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4232,
+                                    "mutability": "mutable",
+                                    "name": "addr",
+                                    "nameLocation": "4352:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4243,
+                                    "src": "4344:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4231,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4344:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4343:14:6"
+                        },
+                        "scope": 4935,
+                        "src": "4272:287:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4253,
+                            "nodeType": "Block",
+                            "src": "4827:34:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4250,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "UnaryOperation",
+                                                "operator": "!",
+                                                "prefix": true,
+                                                "src": "4848:5:6",
+                                                "subExpression": {
+                                                    "id": 4249,
+                                                    "name": "data",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4245,
+                                                    "src": "4849:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 4248,
+                                            "name": "assertTrue",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                2289, 2310
+                                            ],
+                                            "referencedDeclaration": 2289,
+                                            "src": "4837:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_bool_$returns$__$",
+                                                "typeString": "function (bool)"
+                                            }
+                                        },
+                                        "id": 4251,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4837:17:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4252,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "4837:17:6"
+                                }
+                            ]
+                        },
+                        "id": 4254,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertFalse",
+                        "nameLocation": "4787:11:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4246,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4245,
+                                    "mutability": "mutable",
+                                    "name": "data",
+                                    "nameLocation": "4804:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4254,
+                                    "src": "4799:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4244,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4799:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4798:11:6"
+                        },
+                        "returnParameters": {
+                            "id": 4247,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "4827:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "4778:83:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4267,
+                            "nodeType": "Block",
+                            "src": "4935:39:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4263,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "UnaryOperation",
+                                                "operator": "!",
+                                                "prefix": true,
+                                                "src": "4956:5:6",
+                                                "subExpression": {
+                                                    "id": 4262,
+                                                    "name": "data",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4256,
+                                                    "src": "4957:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "id": 4264,
+                                                "name": "err",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4258,
+                                                "src": "4963:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            ],
+                                            "id": 4261,
+                                            "name": "assertTrue",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                2289, 2310
+                                            ],
+                                            "referencedDeclaration": 2310,
+                                            "src": "4945:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory)"
+                                            }
+                                        },
+                                        "id": 4265,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4945:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4266,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "4945:22:6"
+                                }
+                            ]
+                        },
+                        "id": 4268,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertFalse",
+                        "nameLocation": "4876:11:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4259,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4256,
+                                    "mutability": "mutable",
+                                    "name": "data",
+                                    "nameLocation": "4893:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4268,
+                                    "src": "4888:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4255,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4888:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4258,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "4913:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4268,
+                                    "src": "4899:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4257,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4899:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4887:30:6"
+                        },
+                        "returnParameters": {
+                            "id": 4260,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "4935:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "4867:107:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4303,
+                            "nodeType": "Block",
+                            "src": "5023:283:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        },
+                                        "id": 4277,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4275,
+                                            "name": "a",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4270,
+                                            "src": "5037:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "id": 4276,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4272,
+                                            "src": "5042:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "src": "5037:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4302,
+                                    "nodeType": "IfStatement",
+                                    "src": "5033:267:6",
+                                    "trueBody": {
+                                        "id": 4301,
+                                        "nodeType": "Block",
+                                        "src": "5045:255:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061203d3d2062206e6f7420736174697366696564205b626f6f6c5d",
+                                                            "id": 4279,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5084:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_8b48ec9ac4dc7123ad32509232067c63ebae61bff18d5e06bf4dea2a25240ed2",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bool]\""
+                                                            },
+                                                            "value": "Error: a == b not satisfied [bool]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_8b48ec9ac4dc7123ad32509232067c63ebae61bff18d5e06bf4dea2a25240ed2",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bool]\""
+                                                            }
+                                                        ],
+                                                        "id": 4278,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "5064:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4280,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5064:57:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4281,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5059:62:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4283,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5160:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4284,
+                                                                "name": "b",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4272,
+                                                                "src": "5174:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4286,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5187:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4287,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5174:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4285,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5178:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4282,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5140:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4288,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5140:55:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4289,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5135:60:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4291,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5234:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4292,
+                                                                "name": "a",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4270,
+                                                                "src": "5248:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4294,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5261:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4295,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5248:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4293,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5252:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4290,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5214:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4296,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5214:55:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4297,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5209:60:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4298,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "5283:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4299,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5283:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4300,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5283:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4304,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "4989:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4273,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4270,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5003:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4304,
+                                    "src": "4998:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4269,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4998:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4272,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "5011:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4304,
+                                    "src": "5006:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4271,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5006:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4997:16:6"
+                        },
+                        "returnParameters": {
+                            "id": 4274,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "5023:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "4980:326:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4342,
+                            "nodeType": "Block",
+                            "src": "5374:250:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        },
+                                        "id": 4315,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4313,
+                                            "name": "a",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4306,
+                                            "src": "5388:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "id": 4314,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4308,
+                                            "src": "5393:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "src": "5388:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4341,
+                                    "nodeType": "IfStatement",
+                                    "src": "5384:234:6",
+                                    "trueBody": {
+                                        "id": 4340,
+                                        "nodeType": "Block",
+                                        "src": "5396:222:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4317,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5432:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4318,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4310,
+                                                            "src": "5441:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4316,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5415:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4319,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5415:30:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4320,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5410:35:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4322,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5481:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4323,
+                                                                "name": "b",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4308,
+                                                                "src": "5495:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4325,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5508:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4326,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5495:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4324,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5499:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4321,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5464:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4327,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5464:52:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4328,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5459:57:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4330,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5552:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4331,
+                                                                "name": "a",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4306,
+                                                                "src": "5566:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4333,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5579:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4334,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5566:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4332,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5570:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4329,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5535:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4335,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5535:52:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4336,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5530:57:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4337,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "5601:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4338,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5601:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4339,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5601:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4343,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "5321:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4311,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4306,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5335:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4343,
+                                    "src": "5330:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4305,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5330:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4308,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "5343:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4343,
+                                    "src": "5338:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4307,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5338:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4310,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "5360:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4343,
+                                    "src": "5346:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4309,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5346:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "5329:35:6"
+                        },
+                        "returnParameters": {
+                            "id": 4312,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "5374:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "5312:312:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4376,
+                            "nodeType": "Block",
+                            "src": "5697:256:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        },
+                                        "id": 4356,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4351,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4345,
+                                                    "src": "5721:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4350,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "5711:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4352,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "5711:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4354,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4347,
+                                                    "src": "5737:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4353,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "5727:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4355,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "5727:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "src": "5711:28:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4375,
+                                    "nodeType": "IfStatement",
+                                    "src": "5707:240:6",
+                                    "trueBody": {
+                                        "id": 4374,
+                                        "nodeType": "Block",
+                                        "src": "5741:206:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061203d3d2062206e6f7420736174697366696564205b62797465735d",
+                                                            "id": 4358,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5776:37:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_9bb7b728691fe2872efdd27bd07c4a95b3586c3b7ec3afa731a7c21a76e39cfc",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bytes]\""
+                                                            },
+                                                            "value": "Error: a == b not satisfied [bytes]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_9bb7b728691fe2872efdd27bd07c4a95b3586c3b7ec3afa731a7c21a76e39cfc",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bytes]\""
+                                                            }
+                                                        ],
+                                                        "id": 4357,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "5760:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4359,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5760:54:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4360,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5755:59:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4362,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5849:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4363,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4347,
+                                                            "src": "5863:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4361,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "5833:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4364,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5833:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4365,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5828:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4367,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5900:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4368,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4345,
+                                                            "src": "5914:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4366,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "5884:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4369,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5884:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4370,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5879:37:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4371,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "5930:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4372,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5930:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4373,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5930:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4377,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "5639:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4348,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4345,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5661:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4377,
+                                    "src": "5648:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4344,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5648:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4347,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "5677:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4377,
+                                    "src": "5664:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4346,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5664:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "5647:32:6"
+                        },
+                        "returnParameters": {
+                            "id": 4349,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "5697:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "5630:323:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4413,
+                            "nodeType": "Block",
+                            "src": "6045:243:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        },
+                                        "id": 4392,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4387,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4379,
+                                                    "src": "6069:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4386,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "6059:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4388,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "6059:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4390,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4381,
+                                                    "src": "6085:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4389,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "6075:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4391,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "6075:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "src": "6059:28:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4412,
+                                    "nodeType": "IfStatement",
+                                    "src": "6055:227:6",
+                                    "trueBody": {
+                                        "id": 4411,
+                                        "nodeType": "Block",
+                                        "src": "6089:193:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4394,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6128:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4395,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4383,
+                                                            "src": "6137:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4393,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "6108:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4396,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6108:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4397,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6103:38:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4399,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6180:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4400,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4381,
+                                                            "src": "6194:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4398,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "6160:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4401,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6160:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4402,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6155:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4404,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6235:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4405,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4379,
+                                                            "src": "6249:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4403,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "6215:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4406,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6215:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4407,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6210:41:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4408,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "6265:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4409,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6265:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4410,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "6265:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4414,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "5968:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4384,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4379,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5990:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4414,
+                                    "src": "5977:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4378,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5977:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4381,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "6006:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4414,
+                                    "src": "5993:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4380,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5993:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4383,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "6023:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4414,
+                                    "src": "6009:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4382,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6009:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "5976:51:6"
+                        },
+                        "returnParameters": {
+                            "id": 4385,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "6045:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "5959:329:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4468,
+                            "nodeType": "Block",
+                            "src": "6408:404:6",
+                            "statements": [
+                                {
+                                    "assignments": [4424],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4424,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "6426:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4468,
+                                            "src": "6418:13:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4423,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "6418:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4435,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4427,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4425,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4416,
+                                                "src": "6434:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4426,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4418,
+                                                "src": "6438:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6434:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4433,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4431,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4418,
+                                                "src": "6450:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4432,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4416,
+                                                "src": "6454:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6450:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 4434,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "6434:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4430,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4428,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4416,
+                                                "src": "6442:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4429,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4418,
+                                                "src": "6446:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6442:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "6418:37:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4438,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4436,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4424,
+                                            "src": "6470:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4437,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4420,
+                                            "src": "6478:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "6470:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4467,
+                                    "nodeType": "IfStatement",
+                                    "src": "6466:340:6",
+                                    "trueBody": {
+                                        "id": 4466,
+                                        "nodeType": "Block",
+                                        "src": "6488:318:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b75696e745d",
+                                                            "id": 4440,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6523:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [uint]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            }
+                                                        ],
+                                                        "id": 4439,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "6507:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4441,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6507:53:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4442,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6502:58:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4444,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6595:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4445,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4418,
+                                                            "src": "6609:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4443,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6579:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4446,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6579:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4447,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6574:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4449,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6646:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4450,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4416,
+                                                            "src": "6660:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4448,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6630:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4451,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6630:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4452,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6625:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4454,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6697:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4455,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4420,
+                                                            "src": "6711:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4453,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6681:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4456,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6681:39:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4457,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6676:44:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4459,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6755:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4460,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4424,
+                                                            "src": "6769:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4458,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6739:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4461,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6739:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4462,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6734:41:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4463,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "6789:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4464,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6789:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4465,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "6789:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4469,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "6303:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4421,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4416,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "6338:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4469,
+                                    "src": "6330:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4415,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6330:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4418,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "6357:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4469,
+                                    "src": "6349:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4417,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6349:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4420,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "6376:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4469,
+                                    "src": "6368:16:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4419,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6368:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "6320:70:6"
+                        },
+                        "returnParameters": {
+                            "id": 4422,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "6408:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "6294:518:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4526,
+                            "nodeType": "Block",
+                            "src": "6959:400:6",
+                            "statements": [
+                                {
+                                    "assignments": [4481],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4481,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "6977:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4526,
+                                            "src": "6969:13:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4480,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "6969:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4492,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4484,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4482,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4471,
+                                                "src": "6985:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4483,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4473,
+                                                "src": "6989:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6985:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4490,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4488,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4473,
+                                                "src": "7001:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4489,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4471,
+                                                "src": "7005:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "7001:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 4491,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "6985:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4487,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4485,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4471,
+                                                "src": "6993:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4486,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4473,
+                                                "src": "6997:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6993:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "6969:37:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4495,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4493,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4481,
+                                            "src": "7021:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4494,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4475,
+                                            "src": "7029:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "7021:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4525,
+                                    "nodeType": "IfStatement",
+                                    "src": "7017:336:6",
+                                    "trueBody": {
+                                        "id": 4524,
+                                        "nodeType": "Block",
+                                        "src": "7039:314:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4497,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7078:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4498,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4477,
+                                                            "src": "7087:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4496,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "7058:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4499,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7058:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4500,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7053:38:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4502,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7130:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4503,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4473,
+                                                            "src": "7144:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4501,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7110:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4504,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7110:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4505,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7105:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4507,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7185:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4508,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4471,
+                                                            "src": "7199:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4506,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7165:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4509,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7165:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4510,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7160:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4512,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7240:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4513,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4475,
+                                                            "src": "7254:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4511,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7220:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4514,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7220:43:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4515,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7215:48:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4517,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7302:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4518,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4481,
+                                                            "src": "7316:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4516,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7282:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4519,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7282:40:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4520,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7277:45:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4521,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "7336:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4522,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7336:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4523,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "7336:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4527,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "6827:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4478,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4471,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "6862:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6854:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4470,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6854:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4473,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "6881:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6873:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4472,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6873:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4475,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "6900:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6892:16:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4474,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6892:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4477,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "6932:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6918:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4476,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6918:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "6844:97:6"
+                        },
+                        "returnParameters": {
+                            "id": 4479,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "6959:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "6818:541:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4581,
+                            "nodeType": "Block",
+                            "src": "7476:402:6",
+                            "statements": [
+                                {
+                                    "assignments": [4537],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4537,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "7493:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4581,
+                                            "src": "7486:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4536,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "7486:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4548,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4540,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4538,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4529,
+                                                "src": "7501:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4539,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4531,
+                                                "src": "7505:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "7501:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4546,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4544,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4531,
+                                                "src": "7517:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4545,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4529,
+                                                "src": "7521:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "7517:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "id": 4547,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "7501:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4543,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4541,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4529,
+                                                "src": "7509:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4542,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4531,
+                                                "src": "7513:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "7509:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "7486:36:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4551,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4549,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4537,
+                                            "src": "7537:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4550,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4533,
+                                            "src": "7545:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "7537:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4580,
+                                    "nodeType": "IfStatement",
+                                    "src": "7533:339:6",
+                                    "trueBody": {
+                                        "id": 4579,
+                                        "nodeType": "Block",
+                                        "src": "7555:317:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b696e745d",
+                                                            "id": 4553,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7590:35:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_11d61c8cdd58caffa5994831eb66eb6db7a7b4d13b2c9d187ffbe992d75f810d",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [int]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [int]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_11d61c8cdd58caffa5994831eb66eb6db7a7b4d13b2c9d187ffbe992d75f810d",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [int]\""
+                                                            }
+                                                        ],
+                                                        "id": 4552,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "7574:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4554,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7574:52:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4555,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7569:57:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4557,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7661:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4558,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4531,
+                                                            "src": "7675:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4556,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7645:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4559,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7645:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4560,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7640:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4562,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7712:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4563,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4529,
+                                                            "src": "7726:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4561,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7696:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4564,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7696:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4565,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7691:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4567,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7763:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4568,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4533,
+                                                            "src": "7777:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4566,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7747:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4569,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7747:39:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4570,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7742:44:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4572,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7821:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4573,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4537,
+                                                            "src": "7835:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4571,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7805:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4574,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7805:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4575,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7800:41:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4576,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "7855:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4577,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7855:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4578,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "7855:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4582,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "7374:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4534,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4529,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "7408:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4582,
+                                    "src": "7401:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4528,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7401:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4531,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "7426:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4582,
+                                    "src": "7419:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4530,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7419:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4533,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "7444:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4582,
+                                    "src": "7437:15:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4532,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7437:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "7391:67:6"
+                        },
+                        "returnParameters": {
+                            "id": 4535,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "7476:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "7365:513:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4639,
+                            "nodeType": "Block",
+                            "src": "8022:399:6",
+                            "statements": [
+                                {
+                                    "assignments": [4594],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4594,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "8039:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4639,
+                                            "src": "8032:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4593,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "8032:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4605,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4597,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4595,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4584,
+                                                "src": "8047:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4596,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4586,
+                                                "src": "8051:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "8047:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4603,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4601,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4586,
+                                                "src": "8063:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4602,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4584,
+                                                "src": "8067:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "8063:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "id": 4604,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "8047:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4600,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4598,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4584,
+                                                "src": "8055:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4599,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4586,
+                                                "src": "8059:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "8055:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "8032:36:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4608,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4606,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4594,
+                                            "src": "8083:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4607,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4588,
+                                            "src": "8091:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "8083:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4638,
+                                    "nodeType": "IfStatement",
+                                    "src": "8079:336:6",
+                                    "trueBody": {
+                                        "id": 4637,
+                                        "nodeType": "Block",
+                                        "src": "8101:314:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4610,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8140:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4611,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4590,
+                                                            "src": "8149:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4609,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "8120:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4612,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8120:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4613,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8115:38:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4615,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8192:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4616,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4586,
+                                                            "src": "8206:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4614,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8172:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4617,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8172:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4618,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8167:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4620,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8247:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4621,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4584,
+                                                            "src": "8261:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4619,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8227:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4622,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8227:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4623,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8222:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4625,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8302:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4626,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4588,
+                                                            "src": "8316:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4624,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8282:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4627,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8282:43:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4628,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8277:48:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4630,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8364:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4631,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4594,
+                                                            "src": "8378:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4629,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8344:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4632,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8344:40:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4633,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8339:45:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4634,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "8398:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4635,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8398:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4636,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "8398:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4640,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "7893:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4591,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4584,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "7927:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7920:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4583,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7920:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4586,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "7945:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7938:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4585,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7938:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4588,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "7963:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7956:15:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4587,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7956:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4590,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "7995:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7981:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4589,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7981:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "7910:94:6"
+                        },
+                        "returnParameters": {
+                            "id": 4592,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "8022:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "7884:537:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4711,
+                            "nodeType": "Block",
+                            "src": "8604:599:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4651,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4649,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4644,
+                                            "src": "8618:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4650,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "8623:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "8618:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4657,
+                                    "nodeType": "IfStatement",
+                                    "src": "8614:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4653,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4642,
+                                                    "src": "8642:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4654,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4644,
+                                                    "src": "8645:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "id": 4652,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2534,
+                                                "src": "8633:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_uint256_$_t_uint256_$returns$__$",
+                                                    "typeString": "function (uint256,uint256)"
+                                                }
+                                            },
+                                            "id": 4655,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "8633:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4648,
+                                        "id": 4656,
+                                        "nodeType": "Return",
+                                        "src": "8626:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4659],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4659,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "8711:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4711,
+                                            "src": "8703:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4658,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "8703:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4676,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4675,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    "id": 4672,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4662,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4660,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4642,
+                                                                        "src": "8728:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4661,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4644,
+                                                                        "src": "8732:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "8728:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4668,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4666,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4644,
+                                                                        "src": "8744:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4667,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4642,
+                                                                        "src": "8748:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "8744:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "id": 4669,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "8728:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4665,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4663,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4642,
+                                                                        "src": "8736:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4664,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4644,
+                                                                        "src": "8740:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "8736:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4670,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "8727:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4671,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "8753:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "8727:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4673,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "8726:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4674,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4644,
+                                            "src": "8761:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "8726:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "8703:59:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4679,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4677,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4659,
+                                            "src": "8777:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4678,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4646,
+                                            "src": "8792:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "8777:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4710,
+                                    "nodeType": "IfStatement",
+                                    "src": "8773:424:6",
+                                    "trueBody": {
+                                        "id": 4709,
+                                        "nodeType": "Block",
+                                        "src": "8809:388:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b75696e745d",
+                                                            "id": 4681,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8852:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [uint]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            }
+                                                        ],
+                                                        "id": 4680,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "8828:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4682,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8828:61:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4683,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8823:66:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4685,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8932:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4686,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4644,
+                                                            "src": "8948:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4684,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "8908:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4687,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8908:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4688,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8903:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4690,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8993:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4691,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4642,
+                                                            "src": "9009:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4689,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "8969:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4692,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8969:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4693,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8964:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4695,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9054:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4696,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4646,
+                                                            "src": "9070:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4697,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9087:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4694,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9030:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4698,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9030:60:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4699,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9025:65:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4701,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9133:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4702,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4659,
+                                                            "src": "9149:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4703,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9163:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4700,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9109:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4704,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9109:57:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4705,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9104:62:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4706,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "9180:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4707,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9180:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4708,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "9180:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4712,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "8436:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4647,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4642,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "8471:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4712,
+                                    "src": "8463:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4641,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "8463:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4644,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "8490:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4712,
+                                    "src": "8482:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4643,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "8482:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4646,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "8509:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4712,
+                                    "src": "8501:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4645,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "8501:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "8453:133:6"
+                        },
+                        "returnParameters": {
+                            "id": 4648,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "8604:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "8427:776:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4786,
+                            "nodeType": "Block",
+                            "src": "9413:575:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4725,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4723,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4716,
+                                            "src": "9427:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4724,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "9432:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "9427:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4731,
+                                    "nodeType": "IfStatement",
+                                    "src": "9423:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4727,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4714,
+                                                    "src": "9451:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4728,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4716,
+                                                    "src": "9454:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "id": 4726,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2534,
+                                                "src": "9442:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_uint256_$_t_uint256_$returns$__$",
+                                                    "typeString": "function (uint256,uint256)"
+                                                }
+                                            },
+                                            "id": 4729,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "9442:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4722,
+                                        "id": 4730,
+                                        "nodeType": "Return",
+                                        "src": "9435:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4733],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4733,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "9520:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4786,
+                                            "src": "9512:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4732,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "9512:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4750,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4749,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    "id": 4746,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4736,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4734,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4714,
+                                                                        "src": "9537:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4735,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4716,
+                                                                        "src": "9541:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "9537:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4742,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4740,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4716,
+                                                                        "src": "9553:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4741,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4714,
+                                                                        "src": "9557:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "9553:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "id": 4743,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "9537:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4739,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4737,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4714,
+                                                                        "src": "9545:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4738,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4716,
+                                                                        "src": "9549:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "9545:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4744,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "9536:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4745,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "9562:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "9536:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4747,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "9535:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4748,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4716,
+                                            "src": "9570:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "9535:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "9512:59:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4753,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4751,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4733,
+                                            "src": "9586:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4752,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4718,
+                                            "src": "9601:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "9586:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4785,
+                                    "nodeType": "IfStatement",
+                                    "src": "9582:400:6",
+                                    "trueBody": {
+                                        "id": 4784,
+                                        "nodeType": "Block",
+                                        "src": "9618:364:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4755,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9661:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4756,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4720,
+                                                            "src": "9670:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4754,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "9637:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4757,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9637:37:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4758,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9632:42:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4760,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9717:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4761,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4716,
+                                                            "src": "9733:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4759,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "9693:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4762,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9693:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4763,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9688:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4765,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9778:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4766,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4714,
+                                                            "src": "9794:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4764,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "9754:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4767,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9754:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4768,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9749:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4770,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9839:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4771,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4718,
+                                                            "src": "9855:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4772,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9872:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4769,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9815:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4773,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9815:60:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4774,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9810:65:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4776,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9918:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4777,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4733,
+                                                            "src": "9934:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4778,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9948:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4775,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9894:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4779,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9894:57:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4780,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9889:62:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4781,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "9965:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4782,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9965:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4783,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "9965:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4787,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "9218:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4721,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4714,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "9253:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9245:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4713,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9245:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4716,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "9272:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9264:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4715,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9264:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4718,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "9291:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9283:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4717,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9283:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4720,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "9386:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9372:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4719,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9372:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "9235:160:6"
+                        },
+                        "returnParameters": {
+                            "id": 4722,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "9413:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "9209:779:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4858,
+                            "nodeType": "Block",
+                            "src": "10168:593:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4798,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4796,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4791,
+                                            "src": "10182:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4797,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "10187:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "10182:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4804,
+                                    "nodeType": "IfStatement",
+                                    "src": "10178:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4800,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4789,
+                                                    "src": "10206:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4801,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4791,
+                                                    "src": "10209:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                ],
+                                                "id": 4799,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2479,
+                                                "src": "10197:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_int256_$_t_int256_$returns$__$",
+                                                    "typeString": "function (int256,int256)"
+                                                }
+                                            },
+                                            "id": 4802,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "10197:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4795,
+                                        "id": 4803,
+                                        "nodeType": "Return",
+                                        "src": "10190:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4806],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4806,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "10274:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4858,
+                                            "src": "10267:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4805,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "10267:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4823,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4822,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    "id": 4819,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4809,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4807,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4789,
+                                                                        "src": "10291:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4808,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4791,
+                                                                        "src": "10295:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "10291:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4815,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4813,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4791,
+                                                                        "src": "10307:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4814,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4789,
+                                                                        "src": "10311:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "10307:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "id": 4816,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "10291:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4812,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4810,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4789,
+                                                                        "src": "10299:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4811,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4791,
+                                                                        "src": "10303:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "10299:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_int256",
+                                                                    "typeString": "int256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4817,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "10290:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_int256",
+                                                            "typeString": "int256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4818,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "10316:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "10290:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4820,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "10289:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4821,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4791,
+                                            "src": "10324:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "10289:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "10267:58:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4826,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4824,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4806,
+                                            "src": "10340:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4825,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4793,
+                                            "src": "10355:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "10340:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4857,
+                                    "nodeType": "IfStatement",
+                                    "src": "10336:419:6",
+                                    "trueBody": {
+                                        "id": 4856,
+                                        "nodeType": "Block",
+                                        "src": "10372:383:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b75696e745d",
+                                                            "id": 4828,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10414:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [uint]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            }
+                                                        ],
+                                                        "id": 4827,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "10391:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4829,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10391:60:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4830,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10386:65:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4832,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10493:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4833,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4791,
+                                                            "src": "10509:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4831,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "10470:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4834,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10470:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4835,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10465:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4837,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10553:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4838,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4789,
+                                                            "src": "10569:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4836,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "10530:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4839,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10530:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4840,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10525:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4842,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10613:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4843,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4793,
+                                                            "src": "10629:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4844,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10646:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4841,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "10590:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4845,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10590:59:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4846,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10585:64:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4848,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10691:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4849,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4806,
+                                                            "src": "10707:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4850,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10721:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4847,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "10668:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4851,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10668:56:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4852,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10663:61:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4853,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "10738:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4854,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10738:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4855,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "10738:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4859,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "10003:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4794,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4789,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "10037:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4859,
+                                    "src": "10030:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4788,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10030:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4791,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "10055:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4859,
+                                    "src": "10048:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4790,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10048:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4793,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "10073:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4859,
+                                    "src": "10066:22:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4792,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10066:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "10020:130:6"
+                        },
+                        "returnParameters": {
+                            "id": 4795,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "10168:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "9994:767:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4933,
+                            "nodeType": "Block",
+                            "src": "10968:569:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4872,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4870,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4863,
+                                            "src": "10982:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4871,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "10987:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "10982:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4878,
+                                    "nodeType": "IfStatement",
+                                    "src": "10978:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4874,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4861,
+                                                    "src": "11006:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4875,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4863,
+                                                    "src": "11009:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                ],
+                                                "id": 4873,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2479,
+                                                "src": "10997:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_int256_$_t_int256_$returns$__$",
+                                                    "typeString": "function (int256,int256)"
+                                                }
+                                            },
+                                            "id": 4876,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "10997:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4869,
+                                        "id": 4877,
+                                        "nodeType": "Return",
+                                        "src": "10990:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4880],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4880,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "11074:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4933,
+                                            "src": "11067:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4879,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "11067:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4897,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4896,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    "id": 4893,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4883,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4881,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4861,
+                                                                        "src": "11091:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4882,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4863,
+                                                                        "src": "11095:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "11091:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4889,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4887,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4863,
+                                                                        "src": "11107:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4888,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4861,
+                                                                        "src": "11111:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "11107:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "id": 4890,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "11091:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4886,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4884,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4861,
+                                                                        "src": "11099:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4885,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4863,
+                                                                        "src": "11103:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "11099:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_int256",
+                                                                    "typeString": "int256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4891,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "11090:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_int256",
+                                                            "typeString": "int256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4892,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "11116:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "11090:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4894,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "11089:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4895,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4863,
+                                            "src": "11124:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "11089:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "11067:58:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4900,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4898,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4880,
+                                            "src": "11140:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4899,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4865,
+                                            "src": "11155:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "11140:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4932,
+                                    "nodeType": "IfStatement",
+                                    "src": "11136:395:6",
+                                    "trueBody": {
+                                        "id": 4931,
+                                        "nodeType": "Block",
+                                        "src": "11172:359:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4902,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11214:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4903,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4867,
+                                                            "src": "11223:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4901,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "11191:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4904,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11191:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4905,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11186:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4907,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11269:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4908,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4863,
+                                                            "src": "11285:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4906,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "11246:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4909,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11246:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4910,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11241:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4912,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11329:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4913,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4861,
+                                                            "src": "11345:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4911,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "11306:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4914,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11306:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4915,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11301:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4917,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11389:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4918,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4865,
+                                                            "src": "11405:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4919,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11422:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4916,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "11366:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4920,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11366:59:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4921,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11361:64:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4923,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11467:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4924,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4880,
+                                                            "src": "11483:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4925,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11497:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4922,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "11444:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4926,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11444:56:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4927,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11439:61:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4928,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "11514:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4929,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11514:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4930,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "11514:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4934,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "10776:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4868,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4861,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "10810:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10803:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4860,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10803:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4863,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "10828:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10821:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4862,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10821:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4865,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "10846:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10839:22:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4864,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10839:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4867,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "10941:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10927:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4866,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10927:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "10793:157:6"
+                        },
+                        "returnParameters": {
+                            "id": 4869,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "10968:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "10767:770:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    }
+                ],
+                "scope": 5991,
+                "src": "226:11313:6",
+                "usedErrors": []
+            },
+            {
+                "abstract": false,
+                "baseContracts": [],
+                "canonicalName": "stdError",
+                "contractDependencies": [],
+                "contractKind": "library",
+                "fullyImplemented": true,
+                "id": 5005,
+                "linearizedBaseContracts": [5005],
+                "name": "stdError",
+                "nameLocation": "11748:8:6",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "constant": true,
+                        "functionSelector": "10332977",
+                        "id": 4942,
+                        "mutability": "constant",
+                        "name": "assertionError",
+                        "nameLocation": "11785:14:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "11763:86:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4936,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "11763:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4939,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11826:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783031",
+                                    "id": 4940,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11844:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_1_by_1",
+                                        "typeString": "int_const 1"
+                                    },
+                                    "value": "0x01"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_1_by_1",
+                                        "typeString": "int_const 1"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4937,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "11802:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4938,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "11802:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4941,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "11802:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "8995290f",
+                        "id": 4949,
+                        "mutability": "constant",
+                        "name": "arithmeticError",
+                        "nameLocation": "11877:15:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "11855:87:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4943,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "11855:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4946,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11919:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783131",
+                                    "id": 4947,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11937:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_17_by_1",
+                                        "typeString": "int_const 17"
+                                    },
+                                    "value": "0x11"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_17_by_1",
+                                        "typeString": "int_const 17"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4944,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "11895:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4945,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "11895:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4948,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "11895:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "fa784a44",
+                        "id": 4956,
+                        "mutability": "constant",
+                        "name": "divisionError",
+                        "nameLocation": "11970:13:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "11948:85:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4950,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "11948:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4953,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12010:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783132",
+                                    "id": 4954,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12028:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_18_by_1",
+                                        "typeString": "int_const 18"
+                                    },
+                                    "value": "0x12"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_18_by_1",
+                                        "typeString": "int_const 18"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4951,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "11986:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4952,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "11986:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4955,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "11986:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "1de45560",
+                        "id": 4963,
+                        "mutability": "constant",
+                        "name": "enumConversionError",
+                        "nameLocation": "12061:19:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12039:91:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4957,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12039:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4960,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12107:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783231",
+                                    "id": 4961,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12125:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_33_by_1",
+                                        "typeString": "int_const 33"
+                                    },
+                                    "value": "0x21"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_33_by_1",
+                                        "typeString": "int_const 33"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4958,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12083:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4959,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12083:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4962,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12083:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "d160e4de",
+                        "id": 4970,
+                        "mutability": "constant",
+                        "name": "encodeStorageError",
+                        "nameLocation": "12158:18:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12136:90:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4964,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12136:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4967,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12203:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783232",
+                                    "id": 4968,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12221:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_34_by_1",
+                                        "typeString": "int_const 34"
+                                    },
+                                    "value": "0x22"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_34_by_1",
+                                        "typeString": "int_const 34"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4965,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12179:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4966,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12179:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4969,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12179:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "b22dc54d",
+                        "id": 4977,
+                        "mutability": "constant",
+                        "name": "popError",
+                        "nameLocation": "12254:8:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12232:80:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4971,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12232:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4974,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12289:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783331",
+                                    "id": 4975,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12307:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_49_by_1",
+                                        "typeString": "int_const 49"
+                                    },
+                                    "value": "0x31"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_49_by_1",
+                                        "typeString": "int_const 49"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4972,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12265:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4973,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12265:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4976,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12265:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "05ee8612",
+                        "id": 4984,
+                        "mutability": "constant",
+                        "name": "indexOOBError",
+                        "nameLocation": "12340:13:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12318:85:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4978,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12318:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4981,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12380:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783332",
+                                    "id": 4982,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12398:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_50_by_1",
+                                        "typeString": "int_const 50"
+                                    },
+                                    "value": "0x32"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_50_by_1",
+                                        "typeString": "int_const 50"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4979,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12356:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4980,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12356:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4983,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12356:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "986c5f68",
+                        "id": 4991,
+                        "mutability": "constant",
+                        "name": "memOverflowError",
+                        "nameLocation": "12431:16:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12409:88:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4985,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12409:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4988,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12474:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783431",
+                                    "id": 4989,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12492:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_65_by_1",
+                                        "typeString": "int_const 65"
+                                    },
+                                    "value": "0x41"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_65_by_1",
+                                        "typeString": "int_const 65"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4986,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12450:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4987,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12450:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4990,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12450:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "b67689da",
+                        "id": 4998,
+                        "mutability": "constant",
+                        "name": "zeroVarError",
+                        "nameLocation": "12525:12:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12503:84:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4992,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12503:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4995,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12564:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783531",
+                                    "id": 4996,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12582:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_81_by_1",
+                                        "typeString": "int_const 81"
+                                    },
+                                    "value": "0x51"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_81_by_1",
+                                        "typeString": "int_const 81"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4993,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12540:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4994,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12540:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4997,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12540:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "ac3d92c6",
+                        "id": 5004,
+                        "mutability": "constant",
+                        "name": "lowLevelError",
+                        "nameLocation": "12690:13:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12668:47:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4999,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12668:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "",
+                                    "id": 5002,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12712:2:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+                                        "typeString": "literal_string \"\""
+                                    },
+                                    "value": ""
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+                                        "typeString": "literal_string \"\""
+                                    }
+                                ],
+                                "id": 5001,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "nodeType": "ElementaryTypeNameExpression",
+                                "src": "12706:5:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_bytes_storage_ptr_$",
+                                    "typeString": "type(bytes storage pointer)"
+                                },
+                                "typeName": {
+                                    "id": 5000,
+                                    "name": "bytes",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "12706:5:6",
+                                    "typeDescriptions": {}
+                                }
+                            },
+                            "id": 5003,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12706:9:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    }
+                ],
+                "scope": 5991,
+                "src": "11740:986:6",
+                "usedErrors": []
+            },
+            {
+                "canonicalName": "StdStorage",
+                "id": 5033,
+                "members": [
+                    {
+                        "constant": false,
+                        "id": 5013,
+                        "mutability": "mutable",
+                        "name": "slots",
+                        "nameLocation": "13019:5:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "12951:73:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                            "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                        },
+                        "typeName": {
+                            "id": 5012,
+                            "keyType": {
+                                "id": 5006,
+                                "name": "address",
+                                "nodeType": "ElementaryTypeName",
+                                "src": "12960:7:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_address",
+                                    "typeString": "address"
+                                }
+                            },
+                            "nodeType": "Mapping",
+                            "src": "12951:67:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                            },
+                            "valueType": {
+                                "id": 5011,
+                                "keyType": {
+                                    "id": 5007,
+                                    "name": "bytes4",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "12979:6:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    }
+                                },
+                                "nodeType": "Mapping",
+                                "src": "12971:46:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                    "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                },
+                                "valueType": {
+                                    "id": 5010,
+                                    "keyType": {
+                                        "id": 5008,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "12997:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "Mapping",
+                                    "src": "12989:27:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                        "typeString": "mapping(bytes32 => uint256)"
+                                    },
+                                    "valueType": {
+                                        "id": 5009,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13008:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5021,
+                        "mutability": "mutable",
+                        "name": "finds",
+                        "nameLocation": "13096:5:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13030:71:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                            "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                        },
+                        "typeName": {
+                            "id": 5020,
+                            "keyType": {
+                                "id": 5014,
+                                "name": "address",
+                                "nodeType": "ElementaryTypeName",
+                                "src": "13039:7:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_address",
+                                    "typeString": "address"
+                                }
+                            },
+                            "nodeType": "Mapping",
+                            "src": "13030:65:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                            },
+                            "valueType": {
+                                "id": 5019,
+                                "keyType": {
+                                    "id": 5015,
+                                    "name": "bytes4",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "13058:6:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    }
+                                },
+                                "nodeType": "Mapping",
+                                "src": "13050:44:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                    "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                },
+                                "valueType": {
+                                    "id": 5018,
+                                    "keyType": {
+                                        "id": 5016,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13077:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "Mapping",
+                                    "src": "13069:24:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                        "typeString": "mapping(bytes32 => bool)"
+                                    },
+                                    "valueType": {
+                                        "id": 5017,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13088:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5024,
+                        "mutability": "mutable",
+                        "name": "_keys",
+                        "nameLocation": "13118:5:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13108:15:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                            "typeString": "bytes32[]"
+                        },
+                        "typeName": {
+                            "baseType": {
+                                "id": 5022,
+                                "name": "bytes32",
+                                "nodeType": "ElementaryTypeName",
+                                "src": "13108:7:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_bytes32",
+                                    "typeString": "bytes32"
+                                }
+                            },
+                            "id": 5023,
+                            "nodeType": "ArrayTypeName",
+                            "src": "13108:9:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                "typeString": "bytes32[]"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5026,
+                        "mutability": "mutable",
+                        "name": "_sig",
+                        "nameLocation": "13136:4:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13129:11:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes4",
+                            "typeString": "bytes4"
+                        },
+                        "typeName": {
+                            "id": 5025,
+                            "name": "bytes4",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13129:6:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes4",
+                                "typeString": "bytes4"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5028,
+                        "mutability": "mutable",
+                        "name": "_depth",
+                        "nameLocation": "13154:6:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13146:14:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                        },
+                        "typeName": {
+                            "id": 5027,
+                            "name": "uint256",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13146:7:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_uint256",
+                                "typeString": "uint256"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5030,
+                        "mutability": "mutable",
+                        "name": "_target",
+                        "nameLocation": "13174:7:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13166:15:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_address",
+                            "typeString": "address"
+                        },
+                        "typeName": {
+                            "id": 5029,
+                            "name": "address",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13166:7:6",
+                            "stateMutability": "nonpayable",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_address",
+                                "typeString": "address"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5032,
+                        "mutability": "mutable",
+                        "name": "_set",
+                        "nameLocation": "13195:4:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13187:12:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes32",
+                            "typeString": "bytes32"
+                        },
+                        "typeName": {
+                            "id": 5031,
+                            "name": "bytes32",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13187:7:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes32",
+                                "typeString": "bytes32"
+                            }
+                        },
+                        "visibility": "internal"
+                    }
+                ],
+                "name": "StdStorage",
+                "nameLocation": "12934:10:6",
+                "nodeType": "StructDefinition",
+                "scope": 5991,
+                "src": "12927:275:6",
+                "visibility": "public"
+            },
+            {
+                "abstract": false,
+                "baseContracts": [],
+                "canonicalName": "stdStorage",
+                "contractDependencies": [],
+                "contractKind": "library",
+                "fullyImplemented": true,
+                "id": 5990,
+                "linearizedBaseContracts": [5990],
+                "name": "stdStorage",
+                "nameLocation": "13212:10:6",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "anonymous": false,
+                        "id": 5043,
+                        "name": "SlotFound",
+                        "nameLocation": "13235:9:6",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 5042,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5035,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "13253:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13245:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5034,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13245:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5037,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "fsig",
+                                    "nameLocation": "13265:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13258:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    },
+                                    "typeName": {
+                                        "id": 5036,
+                                        "name": "bytes4",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13258:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5039,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "keysHash",
+                                    "nameLocation": "13279:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13271:16:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5038,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13271:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5041,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "slot",
+                                    "nameLocation": "13294:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13289:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5040,
+                                        "name": "uint",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13289:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13244:55:6"
+                        },
+                        "src": "13229:71:6"
+                    },
+                    {
+                        "anonymous": false,
+                        "id": 5049,
+                        "name": "WARNING_UninitedSlot",
+                        "nameLocation": "13311:20:6",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 5048,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5045,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "13340:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5049,
+                                    "src": "13332:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5044,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13332:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5047,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "slot",
+                                    "nameLocation": "13350:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5049,
+                                    "src": "13345:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5046,
+                                        "name": "uint",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13345:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13331:24:6"
+                        },
+                        "src": "13305:51:6"
+                    },
+                    {
+                        "constant": true,
+                        "id": 5066,
+                        "mutability": "constant",
+                        "name": "vm_std_store",
+                        "nameLocation": "13382:12:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5990,
+                        "src": "13362:94:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_Vm_$6200",
+                            "typeString": "contract Vm"
+                        },
+                        "typeName": {
+                            "id": 5051,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 5050,
+                                "name": "Vm",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6200,
+                                "src": "13362:2:6"
+                            },
+                            "referencedDeclaration": 6200,
+                            "src": "13362:2:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "arguments": [
+                                        {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "6865766d20636865617420636f6465",
+                                                                    "id": 5060,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "string",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "13434:17:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_stringliteral_885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d",
+                                                                        "typeString": "literal_string \"hevm cheat code\""
+                                                                    },
+                                                                    "value": "hevm cheat code"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_stringliteral_885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d",
+                                                                        "typeString": "literal_string \"hevm cheat code\""
+                                                                    }
+                                                                ],
+                                                                "id": 5059,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "13424:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5061,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "13424:28:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        ],
+                                                        "id": 5058,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "13416:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_uint256_$",
+                                                            "typeString": "type(uint256)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 5057,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "13416:7:6",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    },
+                                                    "id": 5062,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "typeConversion",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "13416:37:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "id": 5056,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "nodeType": "ElementaryTypeNameExpression",
+                                                "src": "13408:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_uint160_$",
+                                                    "typeString": "type(uint160)"
+                                                },
+                                                "typeName": {
+                                                    "id": 5055,
+                                                    "name": "uint160",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "13408:7:6",
+                                                    "typeDescriptions": {}
+                                                }
+                                            },
+                                            "id": 5063,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "13408:46:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint160",
+                                                "typeString": "uint160"
+                                            }
+                                        }
+                                    ],
+                                    "expression": {
+                                        "argumentTypes": [
+                                            {
+                                                "typeIdentifier": "t_uint160",
+                                                "typeString": "uint160"
+                                            }
+                                        ],
+                                        "id": 5054,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": true,
+                                        "lValueRequested": false,
+                                        "nodeType": "ElementaryTypeNameExpression",
+                                        "src": "13400:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_type$_t_address_$",
+                                            "typeString": "type(address)"
+                                        },
+                                        "typeName": {
+                                            "id": 5053,
+                                            "name": "address",
+                                            "nodeType": "ElementaryTypeName",
+                                            "src": "13400:7:6",
+                                            "typeDescriptions": {}
+                                        }
+                                    },
+                                    "id": 5064,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "typeConversion",
+                                    "lValueRequested": false,
+                                    "names": [],
+                                    "nodeType": "FunctionCall",
+                                    "src": "13400:55:6",
+                                    "tryCall": false,
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                ],
+                                "id": 5052,
+                                "name": "Vm",
+                                "nodeType": "Identifier",
+                                "overloadedDeclarations": [],
+                                "referencedDeclaration": 6200,
+                                "src": "13397:2:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_contract$_Vm_$6200_$",
+                                    "typeString": "type(contract Vm)"
+                                }
+                            },
+                            "id": 5065,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "13397:59:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "visibility": "private"
+                    },
+                    {
+                        "body": {
+                            "id": 5083,
+                            "nodeType": "Block",
+                            "src": "13572:56:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "id": 5078,
+                                                                "name": "sigStr",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5068,
+                                                                "src": "13612:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                                    "typeString": "string memory"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                                    "typeString": "string memory"
+                                                                }
+                                                            ],
+                                                            "id": 5077,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "13606:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_bytes_storage_ptr_$",
+                                                                "typeString": "type(bytes storage pointer)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5076,
+                                                                "name": "bytes",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "13606:5:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5079,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "13606:13:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "id": 5075,
+                                                    "name": "keccak256",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": -8,
+                                                    "src": "13596:9:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                        "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                    }
+                                                },
+                                                "id": 5080,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "13596:24:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5074,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "nodeType": "ElementaryTypeNameExpression",
+                                            "src": "13589:6:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_type$_t_bytes4_$",
+                                                "typeString": "type(bytes4)"
+                                            },
+                                            "typeName": {
+                                                "id": 5073,
+                                                "name": "bytes4",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "13589:6:6",
+                                                "typeDescriptions": {}
+                                            }
+                                        },
+                                        "id": 5081,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "typeConversion",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "13589:32:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5072,
+                                    "id": 5082,
+                                    "nodeType": "Return",
+                                    "src": "13582:39:6"
+                                }
+                            ]
+                        },
+                        "id": 5084,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "sigs",
+                        "nameLocation": "13472:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5069,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5068,
+                                    "mutability": "mutable",
+                                    "name": "sigStr",
+                                    "nameLocation": "13500:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5084,
+                                    "src": "13486:20:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 5067,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13486:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13476:36:6"
+                        },
+                        "returnParameters": {
+                            "id": 5072,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5071,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5084,
+                                    "src": "13560:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    },
+                                    "typeName": {
+                                        "id": 5070,
+                                        "name": "bytes4",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13560:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13559:8:6"
+                        },
+                        "scope": 5990,
+                        "src": "13463:165:6",
+                        "stateMutability": "pure",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5528,
+                            "nodeType": "Block",
+                            "src": "14242:3014:6",
+                            "statements": [
+                                {
+                                    "assignments": [5094],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5094,
+                                            "mutability": "mutable",
+                                            "name": "who",
+                                            "nameLocation": "14260:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14252:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            },
+                                            "typeName": {
+                                                "id": 5093,
+                                                "name": "address",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14252:7:6",
+                                                "stateMutability": "nonpayable",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5097,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5095,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14266:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5096,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_target",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5030,
+                                        "src": "14266:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14252:26:6"
+                                },
+                                {
+                                    "assignments": [5099],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5099,
+                                            "mutability": "mutable",
+                                            "name": "fsig",
+                                            "nameLocation": "14295:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14288:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            },
+                                            "typeName": {
+                                                "id": 5098,
+                                                "name": "bytes4",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14288:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5102,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5100,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14302:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5101,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_sig",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5026,
+                                        "src": "14302:9:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14288:23:6"
+                                },
+                                {
+                                    "assignments": [5104],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5104,
+                                            "mutability": "mutable",
+                                            "name": "field_depth",
+                                            "nameLocation": "14329:11:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14321:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 5103,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14321:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5107,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5105,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14343:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5106,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_depth",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5028,
+                                        "src": "14343:11:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14321:33:6"
+                                },
+                                {
+                                    "assignments": [5112],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5112,
+                                            "mutability": "mutable",
+                                            "name": "ins",
+                                            "nameLocation": "14381:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14364:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                "typeString": "bytes32[]"
+                                            },
+                                            "typeName": {
+                                                "baseType": {
+                                                    "id": 5110,
+                                                    "name": "bytes32",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "14364:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5111,
+                                                "nodeType": "ArrayTypeName",
+                                                "src": "14364:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                                    "typeString": "bytes32[]"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5115,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5113,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14387:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5114,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_keys",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5024,
+                                        "src": "14387:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                            "typeString": "bytes32[] storage ref"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14364:33:6"
+                                },
+                                {
+                                    "condition": {
+                                        "baseExpression": {
+                                            "baseExpression": {
+                                                "baseExpression": {
+                                                    "expression": {
+                                                        "id": 5116,
+                                                        "name": "self",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5088,
+                                                        "src": "14448:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 5117,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "finds",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5021,
+                                                    "src": "14448:10:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                    }
+                                                },
+                                                "id": 5119,
+                                                "indexExpression": {
+                                                    "id": 5118,
+                                                    "name": "who",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5094,
+                                                    "src": "14459:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "14448:15:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                }
+                                            },
+                                            "id": 5121,
+                                            "indexExpression": {
+                                                "id": 5120,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5099,
+                                                "src": "14464:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "IndexAccess",
+                                            "src": "14448:21:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                "typeString": "mapping(bytes32 => bool)"
+                                            }
+                                        },
+                                        "id": 5129,
+                                        "indexExpression": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5125,
+                                                            "name": "ins",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5112,
+                                                            "src": "14497:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "id": 5126,
+                                                            "name": "field_depth",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5104,
+                                                            "src": "14502:11:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 5123,
+                                                            "name": "abi",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -1,
+                                                            "src": "14480:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_abi",
+                                                                "typeString": "abi"
+                                                            }
+                                                        },
+                                                        "id": 5124,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "memberName": "encodePacked",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "14480:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                            "typeString": "function () pure returns (bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 5127,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "14480:34:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 5122,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "14470:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 5128,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "14470:45:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "IndexAccess",
+                                        "src": "14448:68:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5146,
+                                    "nodeType": "IfStatement",
+                                    "src": "14444:174:6",
+                                    "trueBody": {
+                                        "id": 5145,
+                                        "nodeType": "Block",
+                                        "src": "14518:100:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "baseExpression": {
+                                                        "baseExpression": {
+                                                            "baseExpression": {
+                                                                "expression": {
+                                                                    "id": 5130,
+                                                                    "name": "self",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5088,
+                                                                    "src": "14539:4:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                    }
+                                                                },
+                                                                "id": 5131,
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "memberName": "slots",
+                                                                "nodeType": "MemberAccess",
+                                                                "referencedDeclaration": 5013,
+                                                                "src": "14539:10:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                    "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                                }
+                                                            },
+                                                            "id": 5133,
+                                                            "indexExpression": {
+                                                                "id": 5132,
+                                                                "name": "who",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5094,
+                                                                "src": "14550:3:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_address",
+                                                                    "typeString": "address"
+                                                                }
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "14539:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                                "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                            }
+                                                        },
+                                                        "id": 5135,
+                                                        "indexExpression": {
+                                                            "id": 5134,
+                                                            "name": "fsig",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5099,
+                                                            "src": "14555:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes4",
+                                                                "typeString": "bytes4"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "14539:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                            "typeString": "mapping(bytes32 => uint256)"
+                                                        }
+                                                    },
+                                                    "id": 5143,
+                                                    "indexExpression": {
+                                                        "arguments": [
+                                                            {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5139,
+                                                                        "name": "ins",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5112,
+                                                                        "src": "14588:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                            "typeString": "bytes32[] memory"
+                                                                        }
+                                                                    },
+                                                                    {
+                                                                        "id": 5140,
+                                                                        "name": "field_depth",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5104,
+                                                                        "src": "14593:11:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                            "typeString": "bytes32[] memory"
+                                                                        },
+                                                                        {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "id": 5137,
+                                                                        "name": "abi",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": -1,
+                                                                        "src": "14571:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_magic_abi",
+                                                                            "typeString": "abi"
+                                                                        }
+                                                                    },
+                                                                    "id": 5138,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "encodePacked",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "src": "14571:16:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                    }
+                                                                },
+                                                                "id": 5141,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "14571:34:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                    "typeString": "bytes memory"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                    "typeString": "bytes memory"
+                                                                }
+                                                            ],
+                                                            "id": 5136,
+                                                            "name": "keccak256",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -8,
+                                                            "src": "14561:9:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                            }
+                                                        },
+                                                        "id": 5142,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "14561:45:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "14539:68:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "functionReturnParameters": 5092,
+                                                "id": 5144,
+                                                "nodeType": "Return",
+                                                "src": "14532:75:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "assignments": [5148],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5148,
+                                            "mutability": "mutable",
+                                            "name": "cald",
+                                            "nameLocation": "14640:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14627:17:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 5147,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14627:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5156,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 5151,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5099,
+                                                "src": "14664:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5153,
+                                                        "name": "ins",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5112,
+                                                        "src": "14678:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    ],
+                                                    "id": 5152,
+                                                    "name": "flatten",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5989,
+                                                    "src": "14670:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_pure$_t_array$_t_bytes32_$dyn_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes32[] memory) pure returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5154,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "14670:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5149,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "14647:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 5150,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "encodePacked",
+                                            "nodeType": "MemberAccess",
+                                            "src": "14647:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function () pure returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 5155,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "14647:36:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14627:56:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [],
+                                        "expression": {
+                                            "argumentTypes": [],
+                                            "expression": {
+                                                "id": 5157,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "14693:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5159,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "record",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6139,
+                                            "src": "14693:19:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$__$returns$__$",
+                                                "typeString": "function () external"
+                                            }
+                                        },
+                                        "id": 5160,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "14693:21:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5161,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "14693:21:6"
+                                },
+                                {
+                                    "assignments": [5163],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5163,
+                                            "mutability": "mutable",
+                                            "name": "fdat",
+                                            "nameLocation": "14732:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14724:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5162,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14724:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5164,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14724:12:6"
+                                },
+                                {
+                                    "id": 5181,
+                                    "nodeType": "Block",
+                                    "src": "14746:126:6",
+                                    "statements": [
+                                        {
+                                            "assignments": [null, 5166],
+                                            "declarations": [
+                                                null,
+                                                {
+                                                    "constant": false,
+                                                    "id": 5166,
+                                                    "mutability": "mutable",
+                                                    "name": "rdat",
+                                                    "nameLocation": "14776:4:6",
+                                                    "nodeType": "VariableDeclaration",
+                                                    "scope": 5181,
+                                                    "src": "14763:17:6",
+                                                    "stateVariable": false,
+                                                    "storageLocation": "memory",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5165,
+                                                        "name": "bytes",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "14763:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                                            "typeString": "bytes"
+                                                        }
+                                                    },
+                                                    "visibility": "internal"
+                                                }
+                                            ],
+                                            "id": 5171,
+                                            "initialValue": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5169,
+                                                        "name": "cald",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5148,
+                                                        "src": "14799:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 5167,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5094,
+                                                        "src": "14784:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    },
+                                                    "id": 5168,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "staticcall",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "14784:14:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes memory) view returns (bool,bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5170,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "14784:20:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                    "typeString": "tuple(bool,bytes memory)"
+                                                }
+                                            },
+                                            "nodeType": "VariableDeclarationStatement",
+                                            "src": "14760:44:6"
+                                        },
+                                        {
+                                            "expression": {
+                                                "id": 5179,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftHandSide": {
+                                                    "id": 5172,
+                                                    "name": "fdat",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5163,
+                                                    "src": "14818:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "Assignment",
+                                                "operator": "=",
+                                                "rightHandSide": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5174,
+                                                            "name": "rdat",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5166,
+                                                            "src": "14840:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "commonType": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            "id": 5177,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "leftExpression": {
+                                                                "hexValue": "3332",
+                                                                "id": 5175,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "14846:2:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_32_by_1",
+                                                                    "typeString": "int_const 32"
+                                                                },
+                                                                "value": "32"
+                                                            },
+                                                            "nodeType": "BinaryOperation",
+                                                            "operator": "*",
+                                                            "rightExpression": {
+                                                                "id": 5176,
+                                                                "name": "field_depth",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5104,
+                                                                "src": "14849:11:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "src": "14846:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 5173,
+                                                        "name": "bytesToBytes32",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5948,
+                                                        "src": "14825:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_pure$_t_bytes_memory_ptr_$_t_uint256_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory,uint256) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5178,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "14825:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "src": "14818:43:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "id": 5180,
+                                            "nodeType": "ExpressionStatement",
+                                            "src": "14818:43:6"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "assignments": [5186, null],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5186,
+                                            "mutability": "mutable",
+                                            "name": "reads",
+                                            "nameLocation": "14900:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14883:22:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                "typeString": "bytes32[]"
+                                            },
+                                            "typeName": {
+                                                "baseType": {
+                                                    "id": 5184,
+                                                    "name": "bytes32",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "14883:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5185,
+                                                "nodeType": "ArrayTypeName",
+                                                "src": "14883:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                                    "typeString": "bytes32[]"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        },
+                                        null
+                                    ],
+                                    "id": 5194,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5191,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5094,
+                                                        "src": "14941:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 5190,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "14933:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5189,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "14933:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5192,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "14933:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5187,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "14911:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5188,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "accesses",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6150,
+                                            "src": "14911:21:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$_t_array$_t_bytes32_$dyn_memory_ptr_$_t_array$_t_bytes32_$dyn_memory_ptr_$",
+                                                "typeString": "function (address) external returns (bytes32[] memory,bytes32[] memory)"
+                                            }
+                                        },
+                                        "id": 5193,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "14911:35:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$_t_array$_t_bytes32_$dyn_memory_ptr_$_t_array$_t_bytes32_$dyn_memory_ptr_$",
+                                            "typeString": "tuple(bytes32[] memory,bytes32[] memory)"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14882:64:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 5198,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "expression": {
+                                                "id": 5195,
+                                                "name": "reads",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5186,
+                                                "src": "14960:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                    "typeString": "bytes32[] memory"
+                                                }
+                                            },
+                                            "id": 5196,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "length",
+                                            "nodeType": "MemberAccess",
+                                            "src": "14960:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "31",
+                                            "id": 5197,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "14976:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_1_by_1",
+                                                "typeString": "int_const 1"
+                                            },
+                                            "value": "1"
+                                        },
+                                        "src": "14960:17:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "falseBody": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 5300,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "expression": {
+                                                    "id": 5297,
+                                                    "name": "reads",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5186,
+                                                    "src": "15638:5:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                        "typeString": "bytes32[] memory"
+                                                    }
+                                                },
+                                                "id": 5298,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "length",
+                                                "nodeType": "MemberAccess",
+                                                "src": "15638:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "hexValue": "31",
+                                                "id": 5299,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "15653:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1_by_1",
+                                                    "typeString": "int_const 1"
+                                                },
+                                                "value": "1"
+                                            },
+                                            "src": "15638:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseBody": {
+                                            "id": 5476,
+                                            "nodeType": "Block",
+                                            "src": "16876:77:6",
+                                            "statements": [
+                                                {
+                                                    "expression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 5472,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "bool",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "16898:5:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            {
+                                                                "hexValue": "4e6f2073746f726167652075736520646574656374656420666f7220746172676574",
+                                                                "id": 5473,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "16905:36:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_2d47527d82ff490318d5b489ec83c9a0ae26d9e8e2e75850ef5c9e43da453070",
+                                                                    "typeString": "literal_string \"No storage use detected for target\""
+                                                                },
+                                                                "value": "No storage use detected for target"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                },
+                                                                {
+                                                                    "typeIdentifier": "t_stringliteral_2d47527d82ff490318d5b489ec83c9a0ae26d9e8e2e75850ef5c9e43da453070",
+                                                                    "typeString": "literal_string \"No storage use detected for target\""
+                                                                }
+                                                            ],
+                                                            "id": 5471,
+                                                            "name": "require",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [
+                                                                -18, -18
+                                                            ],
+                                                            "referencedDeclaration": -18,
+                                                            "src": "16890:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                                "typeString": "function (bool,string memory) pure"
+                                                            }
+                                                        },
+                                                        "id": 5474,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "16890:52:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_tuple$__$",
+                                                            "typeString": "tuple()"
+                                                        }
+                                                    },
+                                                    "id": 5475,
+                                                    "nodeType": "ExpressionStatement",
+                                                    "src": "16890:52:6"
+                                                }
+                                            ]
+                                        },
+                                        "id": 5477,
+                                        "nodeType": "IfStatement",
+                                        "src": "15634:1319:6",
+                                        "trueBody": {
+                                            "id": 5470,
+                                            "nodeType": "Block",
+                                            "src": "15656:1214:6",
+                                            "statements": [
+                                                {
+                                                    "body": {
+                                                        "id": 5468,
+                                                        "nodeType": "Block",
+                                                        "src": "15713:1147:6",
+                                                        "statements": [
+                                                            {
+                                                                "assignments": [
+                                                                    5313
+                                                                ],
+                                                                "declarations": [
+                                                                    {
+                                                                        "constant": false,
+                                                                        "id": 5313,
+                                                                        "mutability": "mutable",
+                                                                        "name": "prev",
+                                                                        "nameLocation": "15739:4:6",
+                                                                        "nodeType": "VariableDeclaration",
+                                                                        "scope": 5468,
+                                                                        "src": "15731:12:6",
+                                                                        "stateVariable": false,
+                                                                        "storageLocation": "default",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        },
+                                                                        "typeName": {
+                                                                            "id": 5312,
+                                                                            "name": "bytes32",
+                                                                            "nodeType": "ElementaryTypeName",
+                                                                            "src": "15731:7:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "visibility": "internal"
+                                                                    }
+                                                                ],
+                                                                "id": 5321,
+                                                                "initialValue": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5316,
+                                                                            "name": "who",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5094,
+                                                                            "src": "15764:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "baseExpression": {
+                                                                                "id": 5317,
+                                                                                "name": "reads",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5186,
+                                                                                "src": "15769:5:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                    "typeString": "bytes32[] memory"
+                                                                                }
+                                                                            },
+                                                                            "id": 5319,
+                                                                            "indexExpression": {
+                                                                                "id": 5318,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5302,
+                                                                                "src": "15775:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "isConstant": false,
+                                                                            "isLValue": true,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "IndexAccess",
+                                                                            "src": "15769:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5314,
+                                                                            "name": "vm_std_store",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5066,
+                                                                            "src": "15746:12:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                "typeString": "contract Vm"
+                                                                            }
+                                                                        },
+                                                                        "id": 5315,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "load",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 6022,
+                                                                        "src": "15746:17:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$returns$_t_bytes32_$",
+                                                                            "typeString": "function (address,bytes32) external returns (bytes32)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5320,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15746:32:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    }
+                                                                },
+                                                                "nodeType": "VariableDeclarationStatement",
+                                                                "src": "15731:47:6"
+                                                            },
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    },
+                                                                    "id": 5327,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 5322,
+                                                                        "name": "prev",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5313,
+                                                                        "src": "15800:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "==",
+                                                                    "rightExpression": {
+                                                                        "arguments": [
+                                                                            {
+                                                                                "hexValue": "30",
+                                                                                "id": 5325,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": true,
+                                                                                "kind": "number",
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "Literal",
+                                                                                "src": "15816:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                                    "typeString": "int_const 0"
+                                                                                },
+                                                                                "value": "0"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "argumentTypes": [
+                                                                                {
+                                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                                    "typeString": "int_const 0"
+                                                                                }
+                                                                            ],
+                                                                            "id": 5324,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                            "src": "15808:7:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                                "typeString": "type(bytes32)"
+                                                                            },
+                                                                            "typeName": {
+                                                                                "id": 5323,
+                                                                                "name": "bytes32",
+                                                                                "nodeType": "ElementaryTypeName",
+                                                                                "src": "15808:7:6",
+                                                                                "typeDescriptions": {}
+                                                                            }
+                                                                        },
+                                                                        "id": 5326,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "typeConversion",
+                                                                        "lValueRequested": false,
+                                                                        "names": [],
+                                                                        "nodeType": "FunctionCall",
+                                                                        "src": "15808:10:6",
+                                                                        "tryCall": false,
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        }
+                                                                    },
+                                                                    "src": "15800:18:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "id": 5339,
+                                                                "nodeType": "IfStatement",
+                                                                "src": "15796:114:6",
+                                                                "trueBody": {
+                                                                    "id": 5338,
+                                                                    "nodeType": "Block",
+                                                                    "src": "15820:90:6",
+                                                                    "statements": [
+                                                                        {
+                                                                            "eventCall": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5329,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "15868:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "baseExpression": {
+                                                                                                    "id": 5332,
+                                                                                                    "name": "reads",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5186,
+                                                                                                    "src": "15881:5:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                        "typeString": "bytes32[] memory"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5334,
+                                                                                                "indexExpression": {
+                                                                                                    "id": 5333,
+                                                                                                    "name": "i",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5302,
+                                                                                                    "src": "15887:1:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_uint256",
+                                                                                                        "typeString": "uint256"
+                                                                                                    }
+                                                                                                },
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "nodeType": "IndexAccess",
+                                                                                                "src": "15881:8:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5331,
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": false,
+                                                                                            "isPure": true,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                                            "src": "15873:7:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                                "typeString": "type(uint256)"
+                                                                                            },
+                                                                                            "typeName": {
+                                                                                                "id": 5330,
+                                                                                                "name": "uint256",
+                                                                                                "nodeType": "ElementaryTypeName",
+                                                                                                "src": "15873:7:6",
+                                                                                                "typeDescriptions": {}
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5335,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "typeConversion",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "15873:17:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    ],
+                                                                                    "id": 5328,
+                                                                                    "name": "WARNING_UninitedSlot",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5049,
+                                                                                    "src": "15847:20:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                                                        "typeString": "function (address,uint256)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5336,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "15847:44:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                                    "typeString": "tuple()"
+                                                                                }
+                                                                            },
+                                                                            "id": 5337,
+                                                                            "nodeType": "EmitStatement",
+                                                                            "src": "15842:49:6"
+                                                                        }
+                                                                    ]
+                                                                }
+                                                            },
+                                                            {
+                                                                "expression": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5343,
+                                                                            "name": "who",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5094,
+                                                                            "src": "15971:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "baseExpression": {
+                                                                                "id": 5344,
+                                                                                "name": "reads",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5186,
+                                                                                "src": "15976:5:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                    "typeString": "bytes32[] memory"
+                                                                                }
+                                                                            },
+                                                                            "id": 5346,
+                                                                            "indexExpression": {
+                                                                                "id": 5345,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5302,
+                                                                                "src": "15982:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "isConstant": false,
+                                                                            "isLValue": true,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "IndexAccess",
+                                                                            "src": "15976:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "arguments": [
+                                                                                {
+                                                                                    "hexValue": "1337",
+                                                                                    "id": 5349,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "hexString",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "15994:9:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    },
+                                                                                    "value": "\u00137"
+                                                                                }
+                                                                            ],
+                                                                            "expression": {
+                                                                                "argumentTypes": [
+                                                                                    {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    }
+                                                                                ],
+                                                                                "id": 5348,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": true,
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                                "src": "15986:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                                    "typeString": "type(bytes32)"
+                                                                                },
+                                                                                "typeName": {
+                                                                                    "id": 5347,
+                                                                                    "name": "bytes32",
+                                                                                    "nodeType": "ElementaryTypeName",
+                                                                                    "src": "15986:7:6",
+                                                                                    "typeDescriptions": {}
+                                                                                }
+                                                                            },
+                                                                            "id": 5350,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "kind": "typeConversion",
+                                                                            "lValueRequested": false,
+                                                                            "names": [],
+                                                                            "nodeType": "FunctionCall",
+                                                                            "src": "15986:18:6",
+                                                                            "tryCall": false,
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5340,
+                                                                            "name": "vm_std_store",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5066,
+                                                                            "src": "15952:12:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                "typeString": "contract Vm"
+                                                                            }
+                                                                        },
+                                                                        "id": 5342,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "store",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 6031,
+                                                                        "src": "15952:18:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                                            "typeString": "function (address,bytes32,bytes32) external"
+                                                                        }
+                                                                    },
+                                                                    "id": 5351,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15952:53:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_tuple$__$",
+                                                                        "typeString": "tuple()"
+                                                                    }
+                                                                },
+                                                                "id": 5352,
+                                                                "nodeType": "ExpressionStatement",
+                                                                "src": "15952:53:6"
+                                                            },
+                                                            {
+                                                                "assignments": [
+                                                                    5354
+                                                                ],
+                                                                "declarations": [
+                                                                    {
+                                                                        "constant": false,
+                                                                        "id": 5354,
+                                                                        "mutability": "mutable",
+                                                                        "name": "success",
+                                                                        "nameLocation": "16028:7:6",
+                                                                        "nodeType": "VariableDeclaration",
+                                                                        "scope": 5468,
+                                                                        "src": "16023:12:6",
+                                                                        "stateVariable": false,
+                                                                        "storageLocation": "default",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        },
+                                                                        "typeName": {
+                                                                            "id": 5353,
+                                                                            "name": "bool",
+                                                                            "nodeType": "ElementaryTypeName",
+                                                                            "src": "16023:4:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bool",
+                                                                                "typeString": "bool"
+                                                                            }
+                                                                        },
+                                                                        "visibility": "internal"
+                                                                    }
+                                                                ],
+                                                                "id": 5355,
+                                                                "nodeType": "VariableDeclarationStatement",
+                                                                "src": "16023:12:6"
+                                                            },
+                                                            {
+                                                                "assignments": [
+                                                                    5357
+                                                                ],
+                                                                "declarations": [
+                                                                    {
+                                                                        "constant": false,
+                                                                        "id": 5357,
+                                                                        "mutability": "mutable",
+                                                                        "name": "rdat",
+                                                                        "nameLocation": "16066:4:6",
+                                                                        "nodeType": "VariableDeclaration",
+                                                                        "scope": 5468,
+                                                                        "src": "16053:17:6",
+                                                                        "stateVariable": false,
+                                                                        "storageLocation": "memory",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                            "typeString": "bytes"
+                                                                        },
+                                                                        "typeName": {
+                                                                            "id": 5356,
+                                                                            "name": "bytes",
+                                                                            "nodeType": "ElementaryTypeName",
+                                                                            "src": "16053:5:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes_storage_ptr",
+                                                                                "typeString": "bytes"
+                                                                            }
+                                                                        },
+                                                                        "visibility": "internal"
+                                                                    }
+                                                                ],
+                                                                "id": 5358,
+                                                                "nodeType": "VariableDeclarationStatement",
+                                                                "src": "16053:17:6"
+                                                            },
+                                                            {
+                                                                "id": 5377,
+                                                                "nodeType": "Block",
+                                                                "src": "16088:144:6",
+                                                                "statements": [
+                                                                    {
+                                                                        "expression": {
+                                                                            "id": 5366,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftHandSide": {
+                                                                                "components": [
+                                                                                    {
+                                                                                        "id": 5359,
+                                                                                        "name": "success",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5354,
+                                                                                        "src": "16111:7:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bool",
+                                                                                            "typeString": "bool"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "id": 5360,
+                                                                                        "name": "rdat",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5357,
+                                                                                        "src": "16120:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "id": 5361,
+                                                                                "isConstant": false,
+                                                                                "isInlineArray": false,
+                                                                                "isLValue": true,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": true,
+                                                                                "nodeType": "TupleExpression",
+                                                                                "src": "16110:15:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                                                    "typeString": "tuple(bool,bytes memory)"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "Assignment",
+                                                                            "operator": "=",
+                                                                            "rightHandSide": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5364,
+                                                                                        "name": "cald",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5148,
+                                                                                        "src": "16143:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    ],
+                                                                                    "expression": {
+                                                                                        "id": 5362,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "16128:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5363,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": false,
+                                                                                    "memberName": "staticcall",
+                                                                                    "nodeType": "MemberAccess",
+                                                                                    "src": "16128:14:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                                                        "typeString": "function (bytes memory) view returns (bool,bytes memory)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5365,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16128:20:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                                                    "typeString": "tuple(bool,bytes memory)"
+                                                                                }
+                                                                            },
+                                                                            "src": "16110:38:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_tuple$__$",
+                                                                                "typeString": "tuple()"
+                                                                            }
+                                                                        },
+                                                                        "id": 5367,
+                                                                        "nodeType": "ExpressionStatement",
+                                                                        "src": "16110:38:6"
+                                                                    },
+                                                                    {
+                                                                        "expression": {
+                                                                            "id": 5375,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftHandSide": {
+                                                                                "id": 5368,
+                                                                                "name": "fdat",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5163,
+                                                                                "src": "16170:4:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "Assignment",
+                                                                            "operator": "=",
+                                                                            "rightHandSide": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5370,
+                                                                                        "name": "rdat",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5357,
+                                                                                        "src": "16192:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "commonType": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        },
+                                                                                        "id": 5373,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "leftExpression": {
+                                                                                            "hexValue": "3332",
+                                                                                            "id": 5371,
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": false,
+                                                                                            "isPure": true,
+                                                                                            "kind": "number",
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "Literal",
+                                                                                            "src": "16198:2:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_rational_32_by_1",
+                                                                                                "typeString": "int_const 32"
+                                                                                            },
+                                                                                            "value": "32"
+                                                                                        },
+                                                                                        "nodeType": "BinaryOperation",
+                                                                                        "operator": "*",
+                                                                                        "rightExpression": {
+                                                                                            "id": 5372,
+                                                                                            "name": "field_depth",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5104,
+                                                                                            "src": "16201:11:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_uint256",
+                                                                                                "typeString": "uint256"
+                                                                                            }
+                                                                                        },
+                                                                                        "src": "16198:14:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    ],
+                                                                                    "id": 5369,
+                                                                                    "name": "bytesToBytes32",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5948,
+                                                                                    "src": "16177:14:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_internal_pure$_t_bytes_memory_ptr_$_t_uint256_$returns$_t_bytes32_$",
+                                                                                        "typeString": "function (bytes memory,uint256) pure returns (bytes32)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5374,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16177:36:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            },
+                                                                            "src": "16170:43:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "id": 5376,
+                                                                        "nodeType": "ExpressionStatement",
+                                                                        "src": "16170:43:6"
+                                                                    }
+                                                                ]
+                                                            },
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    },
+                                                                    "id": 5385,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 5378,
+                                                                        "name": "success",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5354,
+                                                                        "src": "16254:7:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "&&",
+                                                                    "rightExpression": {
+                                                                        "commonType": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        },
+                                                                        "id": 5384,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "leftExpression": {
+                                                                            "id": 5379,
+                                                                            "name": "fdat",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5163,
+                                                                            "src": "16265:4:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "nodeType": "BinaryOperation",
+                                                                        "operator": "==",
+                                                                        "rightExpression": {
+                                                                            "arguments": [
+                                                                                {
+                                                                                    "hexValue": "1337",
+                                                                                    "id": 5382,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "hexString",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "16281:9:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    },
+                                                                                    "value": "\u00137"
+                                                                                }
+                                                                            ],
+                                                                            "expression": {
+                                                                                "argumentTypes": [
+                                                                                    {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    }
+                                                                                ],
+                                                                                "id": 5381,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": true,
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                                "src": "16273:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                                    "typeString": "type(bytes32)"
+                                                                                },
+                                                                                "typeName": {
+                                                                                    "id": 5380,
+                                                                                    "name": "bytes32",
+                                                                                    "nodeType": "ElementaryTypeName",
+                                                                                    "src": "16273:7:6",
+                                                                                    "typeDescriptions": {}
+                                                                                }
+                                                                            },
+                                                                            "id": 5383,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "kind": "typeConversion",
+                                                                            "lValueRequested": false,
+                                                                            "names": [],
+                                                                            "nodeType": "FunctionCall",
+                                                                            "src": "16273:18:6",
+                                                                            "tryCall": false,
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "src": "16265:26:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        }
+                                                                    },
+                                                                    "src": "16254:37:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "id": 5457,
+                                                                "nodeType": "IfStatement",
+                                                                "src": "16250:539:6",
+                                                                "trueBody": {
+                                                                    "id": 5456,
+                                                                    "nodeType": "Block",
+                                                                    "src": "16293:496:6",
+                                                                    "statements": [
+                                                                        {
+                                                                            "eventCall": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5387,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "16399:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "id": 5388,
+                                                                                        "name": "fsig",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5099,
+                                                                                        "src": "16404:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes4",
+                                                                                            "typeString": "bytes4"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "arguments": [
+                                                                                                    {
+                                                                                                        "id": 5392,
+                                                                                                        "name": "ins",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5112,
+                                                                                                        "src": "16437:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    {
+                                                                                                        "id": 5393,
+                                                                                                        "name": "field_depth",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5104,
+                                                                                                        "src": "16442:11:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    }
+                                                                                                ],
+                                                                                                "expression": {
+                                                                                                    "argumentTypes": [
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        },
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    ],
+                                                                                                    "expression": {
+                                                                                                        "id": 5390,
+                                                                                                        "name": "abi",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": -1,
+                                                                                                        "src": "16420:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_magic_abi",
+                                                                                                            "typeString": "abi"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    "id": 5391,
+                                                                                                    "isConstant": false,
+                                                                                                    "isLValue": false,
+                                                                                                    "isPure": true,
+                                                                                                    "lValueRequested": false,
+                                                                                                    "memberName": "encodePacked",
+                                                                                                    "nodeType": "MemberAccess",
+                                                                                                    "src": "16420:16:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5394,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": false,
+                                                                                                "isPure": false,
+                                                                                                "kind": "functionCall",
+                                                                                                "lValueRequested": false,
+                                                                                                "names": [],
+                                                                                                "nodeType": "FunctionCall",
+                                                                                                "src": "16420:34:6",
+                                                                                                "tryCall": false,
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5389,
+                                                                                            "name": "keccak256",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": -8,
+                                                                                            "src": "16410:9:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5395,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "functionCall",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16410:45:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "baseExpression": {
+                                                                                                    "id": 5398,
+                                                                                                    "name": "reads",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5186,
+                                                                                                    "src": "16465:5:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                        "typeString": "bytes32[] memory"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5400,
+                                                                                                "indexExpression": {
+                                                                                                    "id": 5399,
+                                                                                                    "name": "i",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5302,
+                                                                                                    "src": "16471:1:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_uint256",
+                                                                                                        "typeString": "uint256"
+                                                                                                    }
+                                                                                                },
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "nodeType": "IndexAccess",
+                                                                                                "src": "16465:8:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5397,
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": false,
+                                                                                            "isPure": true,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                                            "src": "16457:7:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                                "typeString": "type(uint256)"
+                                                                                            },
+                                                                                            "typeName": {
+                                                                                                "id": 5396,
+                                                                                                "name": "uint256",
+                                                                                                "nodeType": "ElementaryTypeName",
+                                                                                                "src": "16457:7:6",
+                                                                                                "typeDescriptions": {}
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5401,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "typeConversion",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16457:17:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes4",
+                                                                                            "typeString": "bytes4"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    ],
+                                                                                    "id": 5386,
+                                                                                    "name": "SlotFound",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5043,
+                                                                                    "src": "16389:9:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_bytes4_$_t_bytes32_$_t_uint256_$returns$__$",
+                                                                                        "typeString": "function (address,bytes4,bytes32,uint256)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5402,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16389:86:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                                    "typeString": "tuple()"
+                                                                                }
+                                                                            },
+                                                                            "id": 5403,
+                                                                            "nodeType": "EmitStatement",
+                                                                            "src": "16384:91:6"
+                                                                        },
+                                                                        {
+                                                                            "expression": {
+                                                                                "id": 5425,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": false,
+                                                                                "leftHandSide": {
+                                                                                    "baseExpression": {
+                                                                                        "baseExpression": {
+                                                                                            "baseExpression": {
+                                                                                                "expression": {
+                                                                                                    "id": 5404,
+                                                                                                    "name": "self",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5088,
+                                                                                                    "src": "16497:4:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5415,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "memberName": "slots",
+                                                                                                "nodeType": "MemberAccess",
+                                                                                                "referencedDeclaration": 5013,
+                                                                                                "src": "16497:10:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                                                    "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                                                                }
+                                                                                            },
+                                                                                            "id": 5416,
+                                                                                            "indexExpression": {
+                                                                                                "id": 5406,
+                                                                                                "name": "who",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5094,
+                                                                                                "src": "16508:3:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_address",
+                                                                                                    "typeString": "address"
+                                                                                                }
+                                                                                            },
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": true,
+                                                                                            "isPure": false,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "IndexAccess",
+                                                                                            "src": "16497:15:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                                                                "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5417,
+                                                                                        "indexExpression": {
+                                                                                            "id": 5407,
+                                                                                            "name": "fsig",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5099,
+                                                                                            "src": "16513:4:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_bytes4",
+                                                                                                "typeString": "bytes4"
+                                                                                            }
+                                                                                        },
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": true,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "IndexAccess",
+                                                                                        "src": "16497:21:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                                                            "typeString": "mapping(bytes32 => uint256)"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5418,
+                                                                                    "indexExpression": {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "arguments": [
+                                                                                                    {
+                                                                                                        "id": 5411,
+                                                                                                        "name": "ins",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5112,
+                                                                                                        "src": "16546:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    {
+                                                                                                        "id": 5412,
+                                                                                                        "name": "field_depth",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5104,
+                                                                                                        "src": "16551:11:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    }
+                                                                                                ],
+                                                                                                "expression": {
+                                                                                                    "argumentTypes": [
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        },
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    ],
+                                                                                                    "expression": {
+                                                                                                        "id": 5409,
+                                                                                                        "name": "abi",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": -1,
+                                                                                                        "src": "16529:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_magic_abi",
+                                                                                                            "typeString": "abi"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    "id": 5410,
+                                                                                                    "isConstant": false,
+                                                                                                    "isLValue": false,
+                                                                                                    "isPure": true,
+                                                                                                    "lValueRequested": false,
+                                                                                                    "memberName": "encodePacked",
+                                                                                                    "nodeType": "MemberAccess",
+                                                                                                    "src": "16529:16:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5413,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": false,
+                                                                                                "isPure": false,
+                                                                                                "kind": "functionCall",
+                                                                                                "lValueRequested": false,
+                                                                                                "names": [],
+                                                                                                "nodeType": "FunctionCall",
+                                                                                                "src": "16529:34:6",
+                                                                                                "tryCall": false,
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5408,
+                                                                                            "name": "keccak256",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": -8,
+                                                                                            "src": "16519:9:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5414,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "functionCall",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16519:45:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": true,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": true,
+                                                                                    "nodeType": "IndexAccess",
+                                                                                    "src": "16497:68:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_uint256",
+                                                                                        "typeString": "uint256"
+                                                                                    }
+                                                                                },
+                                                                                "nodeType": "Assignment",
+                                                                                "operator": "=",
+                                                                                "rightHandSide": {
+                                                                                    "arguments": [
+                                                                                        {
+                                                                                            "baseExpression": {
+                                                                                                "id": 5421,
+                                                                                                "name": "reads",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5186,
+                                                                                                "src": "16576:5:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                    "typeString": "bytes32[] memory"
+                                                                                                }
+                                                                                            },
+                                                                                            "id": 5423,
+                                                                                            "indexExpression": {
+                                                                                                "id": 5422,
+                                                                                                "name": "i",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5302,
+                                                                                                "src": "16582:1:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_uint256",
+                                                                                                    "typeString": "uint256"
+                                                                                                }
+                                                                                            },
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": true,
+                                                                                            "isPure": false,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "IndexAccess",
+                                                                                            "src": "16576:8:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_bytes32",
+                                                                                                "typeString": "bytes32"
+                                                                                            }
+                                                                                        }
+                                                                                    ],
+                                                                                    "expression": {
+                                                                                        "argumentTypes": [
+                                                                                            {
+                                                                                                "typeIdentifier": "t_bytes32",
+                                                                                                "typeString": "bytes32"
+                                                                                            }
+                                                                                        ],
+                                                                                        "id": 5420,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": true,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                                                        "src": "16568:7:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                            "typeString": "type(uint256)"
+                                                                                        },
+                                                                                        "typeName": {
+                                                                                            "id": 5419,
+                                                                                            "name": "uint256",
+                                                                                            "nodeType": "ElementaryTypeName",
+                                                                                            "src": "16568:7:6",
+                                                                                            "typeDescriptions": {}
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5424,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": false,
+                                                                                    "kind": "typeConversion",
+                                                                                    "lValueRequested": false,
+                                                                                    "names": [],
+                                                                                    "nodeType": "FunctionCall",
+                                                                                    "src": "16568:17:6",
+                                                                                    "tryCall": false,
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_uint256",
+                                                                                        "typeString": "uint256"
+                                                                                    }
+                                                                                },
+                                                                                "src": "16497:88:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "id": 5426,
+                                                                            "nodeType": "ExpressionStatement",
+                                                                            "src": "16497:88:6"
+                                                                        },
+                                                                        {
+                                                                            "expression": {
+                                                                                "id": 5443,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": false,
+                                                                                "leftHandSide": {
+                                                                                    "baseExpression": {
+                                                                                        "baseExpression": {
+                                                                                            "baseExpression": {
+                                                                                                "expression": {
+                                                                                                    "id": 5427,
+                                                                                                    "name": "self",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5088,
+                                                                                                    "src": "16607:4:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5438,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "memberName": "finds",
+                                                                                                "nodeType": "MemberAccess",
+                                                                                                "referencedDeclaration": 5021,
+                                                                                                "src": "16607:10:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                                                                    "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                                                                }
+                                                                                            },
+                                                                                            "id": 5439,
+                                                                                            "indexExpression": {
+                                                                                                "id": 5429,
+                                                                                                "name": "who",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5094,
+                                                                                                "src": "16618:3:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_address",
+                                                                                                    "typeString": "address"
+                                                                                                }
+                                                                                            },
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": true,
+                                                                                            "isPure": false,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "IndexAccess",
+                                                                                            "src": "16607:15:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                                                                "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5440,
+                                                                                        "indexExpression": {
+                                                                                            "id": 5430,
+                                                                                            "name": "fsig",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5099,
+                                                                                            "src": "16623:4:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_bytes4",
+                                                                                                "typeString": "bytes4"
+                                                                                            }
+                                                                                        },
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": true,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "IndexAccess",
+                                                                                        "src": "16607:21:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                                                            "typeString": "mapping(bytes32 => bool)"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5441,
+                                                                                    "indexExpression": {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "arguments": [
+                                                                                                    {
+                                                                                                        "id": 5434,
+                                                                                                        "name": "ins",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5112,
+                                                                                                        "src": "16656:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    {
+                                                                                                        "id": 5435,
+                                                                                                        "name": "field_depth",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5104,
+                                                                                                        "src": "16661:11:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    }
+                                                                                                ],
+                                                                                                "expression": {
+                                                                                                    "argumentTypes": [
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        },
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    ],
+                                                                                                    "expression": {
+                                                                                                        "id": 5432,
+                                                                                                        "name": "abi",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": -1,
+                                                                                                        "src": "16639:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_magic_abi",
+                                                                                                            "typeString": "abi"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    "id": 5433,
+                                                                                                    "isConstant": false,
+                                                                                                    "isLValue": false,
+                                                                                                    "isPure": true,
+                                                                                                    "lValueRequested": false,
+                                                                                                    "memberName": "encodePacked",
+                                                                                                    "nodeType": "MemberAccess",
+                                                                                                    "src": "16639:16:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5436,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": false,
+                                                                                                "isPure": false,
+                                                                                                "kind": "functionCall",
+                                                                                                "lValueRequested": false,
+                                                                                                "names": [],
+                                                                                                "nodeType": "FunctionCall",
+                                                                                                "src": "16639:34:6",
+                                                                                                "tryCall": false,
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5431,
+                                                                                            "name": "keccak256",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": -8,
+                                                                                            "src": "16629:9:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5437,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "functionCall",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16629:45:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": true,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": true,
+                                                                                    "nodeType": "IndexAccess",
+                                                                                    "src": "16607:68:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_bool",
+                                                                                        "typeString": "bool"
+                                                                                    }
+                                                                                },
+                                                                                "nodeType": "Assignment",
+                                                                                "operator": "=",
+                                                                                "rightHandSide": {
+                                                                                    "hexValue": "74727565",
+                                                                                    "id": 5442,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "bool",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "16678:4:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_bool",
+                                                                                        "typeString": "bool"
+                                                                                    },
+                                                                                    "value": "true"
+                                                                                },
+                                                                                "src": "16607:75:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bool",
+                                                                                    "typeString": "bool"
+                                                                                }
+                                                                            },
+                                                                            "id": 5444,
+                                                                            "nodeType": "ExpressionStatement",
+                                                                            "src": "16607:75:6"
+                                                                        },
+                                                                        {
+                                                                            "expression": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5448,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "16723:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "baseExpression": {
+                                                                                            "id": 5449,
+                                                                                            "name": "reads",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5186,
+                                                                                            "src": "16728:5:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                "typeString": "bytes32[] memory"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5451,
+                                                                                        "indexExpression": {
+                                                                                            "id": 5450,
+                                                                                            "name": "i",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5302,
+                                                                                            "src": "16734:1:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_uint256",
+                                                                                                "typeString": "uint256"
+                                                                                            }
+                                                                                        },
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": true,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "IndexAccess",
+                                                                                        "src": "16728:8:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "id": 5452,
+                                                                                        "name": "prev",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5313,
+                                                                                        "src": "16738:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    ],
+                                                                                    "expression": {
+                                                                                        "id": 5445,
+                                                                                        "name": "vm_std_store",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5066,
+                                                                                        "src": "16704:12:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                            "typeString": "contract Vm"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5447,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": false,
+                                                                                    "memberName": "store",
+                                                                                    "nodeType": "MemberAccess",
+                                                                                    "referencedDeclaration": 6031,
+                                                                                    "src": "16704:18:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                                                        "typeString": "function (address,bytes32,bytes32) external"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5453,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16704:39:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                                    "typeString": "tuple()"
+                                                                                }
+                                                                            },
+                                                                            "id": 5454,
+                                                                            "nodeType": "ExpressionStatement",
+                                                                            "src": "16704:39:6"
+                                                                        },
+                                                                        {
+                                                                            "id": 5455,
+                                                                            "nodeType": "Break",
+                                                                            "src": "16765:5:6"
+                                                                        }
+                                                                    ]
+                                                                }
+                                                            },
+                                                            {
+                                                                "expression": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5461,
+                                                                            "name": "who",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5094,
+                                                                            "src": "16825:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "baseExpression": {
+                                                                                "id": 5462,
+                                                                                "name": "reads",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5186,
+                                                                                "src": "16830:5:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                    "typeString": "bytes32[] memory"
+                                                                                }
+                                                                            },
+                                                                            "id": 5464,
+                                                                            "indexExpression": {
+                                                                                "id": 5463,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5302,
+                                                                                "src": "16836:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "isConstant": false,
+                                                                            "isLValue": true,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "IndexAccess",
+                                                                            "src": "16830:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5465,
+                                                                            "name": "prev",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5313,
+                                                                            "src": "16840:4:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5458,
+                                                                            "name": "vm_std_store",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5066,
+                                                                            "src": "16806:12:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                "typeString": "contract Vm"
+                                                                            }
+                                                                        },
+                                                                        "id": 5460,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "store",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 6031,
+                                                                        "src": "16806:18:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                                            "typeString": "function (address,bytes32,bytes32) external"
+                                                                        }
+                                                                    },
+                                                                    "id": 5466,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "16806:39:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_tuple$__$",
+                                                                        "typeString": "tuple()"
+                                                                    }
+                                                                },
+                                                                "id": 5467,
+                                                                "nodeType": "ExpressionStatement",
+                                                                "src": "16806:39:6"
+                                                            }
+                                                        ]
+                                                    },
+                                                    "condition": {
+                                                        "commonType": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "id": 5308,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "leftExpression": {
+                                                            "id": 5305,
+                                                            "name": "i",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5302,
+                                                            "src": "15690:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "nodeType": "BinaryOperation",
+                                                        "operator": "<",
+                                                        "rightExpression": {
+                                                            "expression": {
+                                                                "id": 5306,
+                                                                "name": "reads",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5186,
+                                                                "src": "15694:5:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                }
+                                                            },
+                                                            "id": 5307,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "length",
+                                                            "nodeType": "MemberAccess",
+                                                            "src": "15694:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "src": "15690:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "id": 5469,
+                                                    "initializationExpression": {
+                                                        "assignments": [5302],
+                                                        "declarations": [
+                                                            {
+                                                                "constant": false,
+                                                                "id": 5302,
+                                                                "mutability": "mutable",
+                                                                "name": "i",
+                                                                "nameLocation": "15683:1:6",
+                                                                "nodeType": "VariableDeclaration",
+                                                                "scope": 5469,
+                                                                "src": "15675:9:6",
+                                                                "stateVariable": false,
+                                                                "storageLocation": "default",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 5301,
+                                                                    "name": "uint256",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "15675:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "visibility": "internal"
+                                                            }
+                                                        ],
+                                                        "id": 5304,
+                                                        "initialValue": {
+                                                            "hexValue": "30",
+                                                            "id": 5303,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "15687:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_0_by_1",
+                                                                "typeString": "int_const 0"
+                                                            },
+                                                            "value": "0"
+                                                        },
+                                                        "nodeType": "VariableDeclarationStatement",
+                                                        "src": "15675:13:6"
+                                                    },
+                                                    "loopExpression": {
+                                                        "expression": {
+                                                            "id": 5310,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "UnaryOperation",
+                                                            "operator": "++",
+                                                            "prefix": false,
+                                                            "src": "15708:3:6",
+                                                            "subExpression": {
+                                                                "id": 5309,
+                                                                "name": "i",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5302,
+                                                                "src": "15708:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "id": 5311,
+                                                        "nodeType": "ExpressionStatement",
+                                                        "src": "15708:3:6"
+                                                    },
+                                                    "nodeType": "ForStatement",
+                                                    "src": "15670:1190:6"
+                                                }
+                                            ]
+                                        }
+                                    },
+                                    "id": 5478,
+                                    "nodeType": "IfStatement",
+                                    "src": "14956:1997:6",
+                                    "trueBody": {
+                                        "id": 5296,
+                                        "nodeType": "Block",
+                                        "src": "14979:649:6",
+                                        "statements": [
+                                            {
+                                                "assignments": [5200],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 5200,
+                                                        "mutability": "mutable",
+                                                        "name": "curr",
+                                                        "nameLocation": "15001:4:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 5296,
+                                                        "src": "14993:12:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 5199,
+                                                            "name": "bytes32",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "14993:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 5208,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5203,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5094,
+                                                            "src": "15026:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        {
+                                                            "baseExpression": {
+                                                                "id": 5204,
+                                                                "name": "reads",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5186,
+                                                                "src": "15031:5:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                }
+                                                            },
+                                                            "id": 5206,
+                                                            "indexExpression": {
+                                                                "hexValue": "30",
+                                                                "id": 5205,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "15037:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                    "typeString": "int_const 0"
+                                                                },
+                                                                "value": "0"
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "15031:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 5201,
+                                                            "name": "vm_std_store",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5066,
+                                                            "src": "15008:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                "typeString": "contract Vm"
+                                                            }
+                                                        },
+                                                        "id": 5202,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "load",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 6022,
+                                                        "src": "15008:17:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$returns$_t_bytes32_$",
+                                                            "typeString": "function (address,bytes32) external returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5207,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "15008:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "14993:47:6"
+                                            },
+                                            {
+                                                "condition": {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    },
+                                                    "id": 5214,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "id": 5209,
+                                                        "name": "curr",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5200,
+                                                        "src": "15058:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "==",
+                                                    "rightExpression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "30",
+                                                                "id": 5212,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "15074:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                    "typeString": "int_const 0"
+                                                                },
+                                                                "value": "0"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                    "typeString": "int_const 0"
+                                                                }
+                                                            ],
+                                                            "id": 5211,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "15066:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                "typeString": "type(bytes32)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5210,
+                                                                "name": "bytes32",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "15066:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5213,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "15066:10:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "src": "15058:18:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 5226,
+                                                "nodeType": "IfStatement",
+                                                "src": "15054:106:6",
+                                                "trueBody": {
+                                                    "id": 5225,
+                                                    "nodeType": "Block",
+                                                    "src": "15078:82:6",
+                                                    "statements": [
+                                                        {
+                                                            "eventCall": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5216,
+                                                                        "name": "who",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5094,
+                                                                        "src": "15122:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    },
+                                                                    {
+                                                                        "arguments": [
+                                                                            {
+                                                                                "baseExpression": {
+                                                                                    "id": 5219,
+                                                                                    "name": "reads",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5186,
+                                                                                    "src": "15135:5:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                        "typeString": "bytes32[] memory"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5221,
+                                                                                "indexExpression": {
+                                                                                    "hexValue": "30",
+                                                                                    "id": 5220,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "number",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "15141:1:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_rational_0_by_1",
+                                                                                        "typeString": "int_const 0"
+                                                                                    },
+                                                                                    "value": "0"
+                                                                                },
+                                                                                "isConstant": false,
+                                                                                "isLValue": true,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "IndexAccess",
+                                                                                "src": "15135:8:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "argumentTypes": [
+                                                                                {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            ],
+                                                                            "id": 5218,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                            "src": "15127:7:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                "typeString": "type(uint256)"
+                                                                            },
+                                                                            "typeName": {
+                                                                                "id": 5217,
+                                                                                "name": "uint256",
+                                                                                "nodeType": "ElementaryTypeName",
+                                                                                "src": "15127:7:6",
+                                                                                "typeDescriptions": {}
+                                                                            }
+                                                                        },
+                                                                        "id": 5222,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "kind": "typeConversion",
+                                                                        "lValueRequested": false,
+                                                                        "names": [],
+                                                                        "nodeType": "FunctionCall",
+                                                                        "src": "15127:17:6",
+                                                                        "tryCall": false,
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        },
+                                                                        {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    ],
+                                                                    "id": 5215,
+                                                                    "name": "WARNING_UninitedSlot",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5049,
+                                                                    "src": "15101:20:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                                        "typeString": "function (address,uint256)"
+                                                                    }
+                                                                },
+                                                                "id": 5223,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "15101:44:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                    "typeString": "tuple()"
+                                                                }
+                                                            },
+                                                            "id": 5224,
+                                                            "nodeType": "EmitStatement",
+                                                            "src": "15096:49:6"
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                "condition": {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    },
+                                                    "id": 5229,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "id": 5227,
+                                                        "name": "fdat",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5163,
+                                                        "src": "15177:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "!=",
+                                                    "rightExpression": {
+                                                        "id": 5228,
+                                                        "name": "curr",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5200,
+                                                        "src": "15185:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "src": "15177:12:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 5236,
+                                                "nodeType": "IfStatement",
+                                                "src": "15173:149:6",
+                                                "trueBody": {
+                                                    "id": 5235,
+                                                    "nodeType": "Block",
+                                                    "src": "15191:131:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "hexValue": "66616c7365",
+                                                                        "id": 5231,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "bool",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "15217:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        },
+                                                                        "value": "false"
+                                                                    },
+                                                                    {
+                                                                        "hexValue": "5061636b656420736c6f742e205468697320776f756c642063617573652064616e6765726f7573206f76657277726974696e6720616e642063757272656e746c792069736e7420737570706f72746564",
+                                                                        "id": 5232,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "string",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "15224:82:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                            "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                                        },
+                                                                        "value": "Packed slot. This would cause dangerous overwriting and currently isnt supported"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        },
+                                                                        {
+                                                                            "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                            "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                                        }
+                                                                    ],
+                                                                    "id": 5230,
+                                                                    "name": "require",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [
+                                                                        -18, -18
+                                                                    ],
+                                                                    "referencedDeclaration": -18,
+                                                                    "src": "15209:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                                        "typeString": "function (bool,string memory) pure"
+                                                                    }
+                                                                },
+                                                                "id": 5233,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "15209:98:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                    "typeString": "tuple()"
+                                                                }
+                                                            },
+                                                            "id": 5234,
+                                                            "nodeType": "ExpressionStatement",
+                                                            "src": "15209:98:6"
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5238,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5094,
+                                                            "src": "15350:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        {
+                                                            "id": 5239,
+                                                            "name": "fsig",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5099,
+                                                            "src": "15355:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes4",
+                                                                "typeString": "bytes4"
+                                                            }
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5243,
+                                                                            "name": "ins",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5112,
+                                                                            "src": "15388:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5244,
+                                                                            "name": "field_depth",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5104,
+                                                                            "src": "15393:11:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5241,
+                                                                            "name": "abi",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": -1,
+                                                                            "src": "15371:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_magic_abi",
+                                                                                "typeString": "abi"
+                                                                            }
+                                                                        },
+                                                                        "id": 5242,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "encodePacked",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "src": "15371:16:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                            "typeString": "function () pure returns (bytes memory)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5245,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15371:34:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                ],
+                                                                "id": 5240,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "15361:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5246,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15361:45:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "baseExpression": {
+                                                                        "id": 5249,
+                                                                        "name": "reads",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5186,
+                                                                        "src": "15416:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                            "typeString": "bytes32[] memory"
+                                                                        }
+                                                                    },
+                                                                    "id": 5251,
+                                                                    "indexExpression": {
+                                                                        "hexValue": "30",
+                                                                        "id": 5250,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "number",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "15422:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_rational_0_by_1",
+                                                                            "typeString": "int_const 0"
+                                                                        },
+                                                                        "value": "0"
+                                                                    },
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "IndexAccess",
+                                                                    "src": "15416:8:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    }
+                                                                ],
+                                                                "id": 5248,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "15408:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_uint256_$",
+                                                                    "typeString": "type(uint256)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 5247,
+                                                                    "name": "uint256",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "15408:7:6",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 5252,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15408:17:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes4",
+                                                                "typeString": "bytes4"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 5237,
+                                                        "name": "SlotFound",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5043,
+                                                        "src": "15340:9:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_bytes4_$_t_bytes32_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (address,bytes4,bytes32,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 5253,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "15340:86:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 5254,
+                                                "nodeType": "EmitStatement",
+                                                "src": "15335:91:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 5276,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "baseExpression": {
+                                                            "baseExpression": {
+                                                                "baseExpression": {
+                                                                    "expression": {
+                                                                        "id": 5255,
+                                                                        "name": "self",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5088,
+                                                                        "src": "15440:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                            "typeString": "struct StdStorage storage pointer"
+                                                                        }
+                                                                    },
+                                                                    "id": 5266,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "slots",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5013,
+                                                                    "src": "15440:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                                    }
+                                                                },
+                                                                "id": 5267,
+                                                                "indexExpression": {
+                                                                    "id": 5257,
+                                                                    "name": "who",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5094,
+                                                                    "src": "15451:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                },
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "IndexAccess",
+                                                                "src": "15440:15:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                                }
+                                                            },
+                                                            "id": 5268,
+                                                            "indexExpression": {
+                                                                "id": 5258,
+                                                                "name": "fsig",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5099,
+                                                                "src": "15456:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes4",
+                                                                    "typeString": "bytes4"
+                                                                }
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "15440:21:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                                "typeString": "mapping(bytes32 => uint256)"
+                                                            }
+                                                        },
+                                                        "id": 5269,
+                                                        "indexExpression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5262,
+                                                                            "name": "ins",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5112,
+                                                                            "src": "15489:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5263,
+                                                                            "name": "field_depth",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5104,
+                                                                            "src": "15494:11:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5260,
+                                                                            "name": "abi",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": -1,
+                                                                            "src": "15472:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_magic_abi",
+                                                                                "typeString": "abi"
+                                                                            }
+                                                                        },
+                                                                        "id": 5261,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "encodePacked",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "src": "15472:16:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                            "typeString": "function () pure returns (bytes memory)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5264,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15472:34:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                ],
+                                                                "id": 5259,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "15462:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5265,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15462:45:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "15440:68:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "arguments": [
+                                                            {
+                                                                "baseExpression": {
+                                                                    "id": 5272,
+                                                                    "name": "reads",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5186,
+                                                                    "src": "15519:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    }
+                                                                },
+                                                                "id": 5274,
+                                                                "indexExpression": {
+                                                                    "hexValue": "30",
+                                                                    "id": 5273,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "15525:1:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_rational_0_by_1",
+                                                                        "typeString": "int_const 0"
+                                                                    },
+                                                                    "value": "0"
+                                                                },
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "IndexAccess",
+                                                                "src": "15519:8:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes32",
+                                                                    "typeString": "bytes32"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_bytes32",
+                                                                    "typeString": "bytes32"
+                                                                }
+                                                            ],
+                                                            "id": 5271,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "15511:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5270,
+                                                                "name": "uint256",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "15511:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5275,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "15511:17:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "15440:88:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 5277,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "15440:88:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 5294,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "baseExpression": {
+                                                            "baseExpression": {
+                                                                "baseExpression": {
+                                                                    "expression": {
+                                                                        "id": 5278,
+                                                                        "name": "self",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5088,
+                                                                        "src": "15542:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                            "typeString": "struct StdStorage storage pointer"
+                                                                        }
+                                                                    },
+                                                                    "id": 5289,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "finds",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5021,
+                                                                    "src": "15542:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                                    }
+                                                                },
+                                                                "id": 5290,
+                                                                "indexExpression": {
+                                                                    "id": 5280,
+                                                                    "name": "who",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5094,
+                                                                    "src": "15553:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                },
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "IndexAccess",
+                                                                "src": "15542:15:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                                }
+                                                            },
+                                                            "id": 5291,
+                                                            "indexExpression": {
+                                                                "id": 5281,
+                                                                "name": "fsig",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5099,
+                                                                "src": "15558:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes4",
+                                                                    "typeString": "bytes4"
+                                                                }
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "15542:21:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                                "typeString": "mapping(bytes32 => bool)"
+                                                            }
+                                                        },
+                                                        "id": 5292,
+                                                        "indexExpression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5285,
+                                                                            "name": "ins",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5112,
+                                                                            "src": "15591:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5286,
+                                                                            "name": "field_depth",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5104,
+                                                                            "src": "15596:11:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5283,
+                                                                            "name": "abi",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": -1,
+                                                                            "src": "15574:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_magic_abi",
+                                                                                "typeString": "abi"
+                                                                            }
+                                                                        },
+                                                                        "id": 5284,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "encodePacked",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "src": "15574:16:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                            "typeString": "function () pure returns (bytes memory)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5287,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15574:34:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                ],
+                                                                "id": 5282,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "15564:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5288,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15564:45:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "15542:68:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "74727565",
+                                                        "id": 5293,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "15613:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "true"
+                                                    },
+                                                    "src": "15542:75:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 5295,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "15542:75:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "baseExpression": {
+                                                    "baseExpression": {
+                                                        "baseExpression": {
+                                                            "expression": {
+                                                                "id": 5480,
+                                                                "name": "self",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5088,
+                                                                "src": "16971:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 5481,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "finds",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5021,
+                                                            "src": "16971:10:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                            }
+                                                        },
+                                                        "id": 5483,
+                                                        "indexExpression": {
+                                                            "id": 5482,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5094,
+                                                            "src": "16982:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "16971:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                            "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                        }
+                                                    },
+                                                    "id": 5485,
+                                                    "indexExpression": {
+                                                        "id": 5484,
+                                                        "name": "fsig",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5099,
+                                                        "src": "16987:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes4",
+                                                            "typeString": "bytes4"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "16971:21:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                        "typeString": "mapping(bytes32 => bool)"
+                                                    }
+                                                },
+                                                "id": 5493,
+                                                "indexExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "id": 5489,
+                                                                    "name": "ins",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5112,
+                                                                    "src": "17020:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    }
+                                                                },
+                                                                {
+                                                                    "id": 5490,
+                                                                    "name": "field_depth",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5104,
+                                                                    "src": "17025:11:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    },
+                                                                    {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "id": 5487,
+                                                                    "name": "abi",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": -1,
+                                                                    "src": "17003:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_magic_abi",
+                                                                        "typeString": "abi"
+                                                                    }
+                                                                },
+                                                                "id": 5488,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "memberName": "encodePacked",
+                                                                "nodeType": "MemberAccess",
+                                                                "src": "17003:16:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                    "typeString": "function () pure returns (bytes memory)"
+                                                                }
+                                                            },
+                                                            "id": 5491,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "17003:34:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 5486,
+                                                        "name": "keccak256",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -8,
+                                                        "src": "16993:9:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5492,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "16993:45:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "16971:68:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "4e6f74466f756e64",
+                                                "id": 5494,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "17041:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_a896e77af5e233b52f3d565f8bd98eec0ddb0e671485cda84d2cd93d51849a53",
+                                                    "typeString": "literal_string \"NotFound\""
+                                                },
+                                                "value": "NotFound"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_a896e77af5e233b52f3d565f8bd98eec0ddb0e671485cda84d2cd93d51849a53",
+                                                    "typeString": "literal_string \"NotFound\""
+                                                }
+                                            ],
+                                            "id": 5479,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "16963:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 5495,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "16963:89:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5496,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "16963:89:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5499,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17063:19:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5497,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17070:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5498,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_target",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5030,
+                                            "src": "17070:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5500,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17063:19:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5503,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17092:16:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5501,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17099:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5502,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "17099:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5504,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17092:16:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5507,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17118:17:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5505,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17125:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5506,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_keys",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5024,
+                                            "src": "17125:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                "typeString": "bytes32[] storage ref"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5508,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17118:17:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5511,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17145:18:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5509,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17152:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5510,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_depth",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5028,
+                                            "src": "17152:11:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5512,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17145:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "baseExpression": {
+                                            "baseExpression": {
+                                                "baseExpression": {
+                                                    "expression": {
+                                                        "id": 5513,
+                                                        "name": "self",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5088,
+                                                        "src": "17181:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 5514,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "slots",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5013,
+                                                    "src": "17181:10:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                    }
+                                                },
+                                                "id": 5516,
+                                                "indexExpression": {
+                                                    "id": 5515,
+                                                    "name": "who",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5094,
+                                                    "src": "17192:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "17181:15:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                }
+                                            },
+                                            "id": 5518,
+                                            "indexExpression": {
+                                                "id": 5517,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5099,
+                                                "src": "17197:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "IndexAccess",
+                                            "src": "17181:21:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                "typeString": "mapping(bytes32 => uint256)"
+                                            }
+                                        },
+                                        "id": 5526,
+                                        "indexExpression": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5522,
+                                                            "name": "ins",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5112,
+                                                            "src": "17230:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "id": 5523,
+                                                            "name": "field_depth",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5104,
+                                                            "src": "17235:11:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 5520,
+                                                            "name": "abi",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -1,
+                                                            "src": "17213:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_abi",
+                                                                "typeString": "abi"
+                                                            }
+                                                        },
+                                                        "id": 5521,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "memberName": "encodePacked",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "17213:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                            "typeString": "function () pure returns (bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 5524,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "17213:34:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 5519,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "17203:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 5525,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "17203:45:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "IndexAccess",
+                                        "src": "17181:68:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5092,
+                                    "id": 5527,
+                                    "nodeType": "Return",
+                                    "src": "17174:75:6"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 5085,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "13634:129:6",
+                            "text": "@notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against"
+                        },
+                        "id": 5529,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "find",
+                        "nameLocation": "14151:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5089,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5088,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "14184:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5529,
+                                    "src": "14165:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5087,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5086,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "14165:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "14165:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "14155:39:6"
+                        },
+                        "returnParameters": {
+                            "id": 5092,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5091,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5529,
+                                    "src": "14229:7:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5090,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "14229:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "14228:9:6"
+                        },
+                        "scope": 5990,
+                        "src": "14142:3114:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5548,
+                            "nodeType": "Block",
+                            "src": "17358:60:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5544,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5540,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5532,
+                                                "src": "17368:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5542,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_target",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5030,
+                                            "src": "17368:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 5543,
+                                            "name": "_target",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5534,
+                                            "src": "17383:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "src": "17368:22:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "id": 5545,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17368:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5546,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5532,
+                                        "src": "17407:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5539,
+                                    "id": 5547,
+                                    "nodeType": "Return",
+                                    "src": "17400:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5549,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "target",
+                        "nameLocation": "17271:6:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5535,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5532,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17297:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5549,
+                                    "src": "17278:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5531,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5530,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17278:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17278:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5534,
+                                    "mutability": "mutable",
+                                    "name": "_target",
+                                    "nameLocation": "17311:7:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5549,
+                                    "src": "17303:15:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5533,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17303:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17277:42:6"
+                        },
+                        "returnParameters": {
+                            "id": 5539,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5538,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5549,
+                                    "src": "17338:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5537,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5536,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17338:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17338:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17337:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17262:156:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5568,
+                            "nodeType": "Block",
+                            "src": "17513:54:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5564,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5560,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5552,
+                                                "src": "17523:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5562,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "17523:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 5563,
+                                            "name": "_sig",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5554,
+                                            "src": "17535:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "src": "17523:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "id": 5565,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17523:16:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5566,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5552,
+                                        "src": "17556:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5559,
+                                    "id": 5567,
+                                    "nodeType": "Return",
+                                    "src": "17549:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5569,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "sig",
+                        "nameLocation": "17433:3:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5555,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5552,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17456:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5569,
+                                    "src": "17437:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5551,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5550,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17437:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17437:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5554,
+                                    "mutability": "mutable",
+                                    "name": "_sig",
+                                    "nameLocation": "17469:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5569,
+                                    "src": "17462:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    },
+                                    "typeName": {
+                                        "id": 5553,
+                                        "name": "bytes4",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17462:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17436:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5559,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5558,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5569,
+                                    "src": "17493:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5557,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5556,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17493:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17493:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17492:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17424:143:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5590,
+                            "nodeType": "Block",
+                            "src": "17669:60:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5586,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5580,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5572,
+                                                "src": "17679:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5582,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "17679:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 5584,
+                                                    "name": "_sig",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5574,
+                                                    "src": "17696:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_string_memory_ptr",
+                                                        "typeString": "string memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_string_memory_ptr",
+                                                        "typeString": "string memory"
+                                                    }
+                                                ],
+                                                "id": 5583,
+                                                "name": "sigs",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5084,
+                                                "src": "17691:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_pure$_t_string_memory_ptr_$returns$_t_bytes4_$",
+                                                    "typeString": "function (string memory) pure returns (bytes4)"
+                                                }
+                                            },
+                                            "id": 5585,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "17691:10:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "src": "17679:22:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "id": 5587,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17679:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5588,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5572,
+                                        "src": "17718:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5579,
+                                    "id": 5589,
+                                    "nodeType": "Return",
+                                    "src": "17711:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5591,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "sig",
+                        "nameLocation": "17582:3:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5575,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5572,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17605:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5591,
+                                    "src": "17586:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5571,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5570,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17586:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17586:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5574,
+                                    "mutability": "mutable",
+                                    "name": "_sig",
+                                    "nameLocation": "17625:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5591,
+                                    "src": "17611:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 5573,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17611:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17585:45:6"
+                        },
+                        "returnParameters": {
+                            "id": 5579,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5578,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5591,
+                                    "src": "17649:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5577,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5576,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17649:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17649:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17648:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17573:156:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5621,
+                            "nodeType": "Block",
+                            "src": "17829:85:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5613,
+                                                                        "name": "who",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5596,
+                                                                        "src": "17879:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "id": 5612,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                                    "src": "17871:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_type$_t_uint160_$",
+                                                                        "typeString": "type(uint160)"
+                                                                    },
+                                                                    "typeName": {
+                                                                        "id": 5611,
+                                                                        "name": "uint160",
+                                                                        "nodeType": "ElementaryTypeName",
+                                                                        "src": "17871:7:6",
+                                                                        "typeDescriptions": {}
+                                                                    }
+                                                                },
+                                                                "id": 5614,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "typeConversion",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "17871:12:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            ],
+                                                            "id": 5610,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "17863:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5609,
+                                                                "name": "uint256",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "17863:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5615,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "17863:21:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5608,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "17855:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5607,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "17855:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5616,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "17855:30:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "expression": {
+                                                    "id": 5602,
+                                                    "name": "self",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5594,
+                                                    "src": "17839:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                        "typeString": "struct StdStorage storage pointer"
+                                                    }
+                                                },
+                                                "id": 5605,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "_keys",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5024,
+                                                "src": "17839:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                    "typeString": "bytes32[] storage ref"
+                                                }
+                                            },
+                                            "id": 5606,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "push",
+                                            "nodeType": "MemberAccess",
+                                            "src": "17839:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_arraypush_nonpayable$_t_array$_t_bytes32_$dyn_storage_ptr_$_t_bytes32_$returns$__$bound_to$_t_array$_t_bytes32_$dyn_storage_ptr_$",
+                                                "typeString": "function (bytes32[] storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5617,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "17839:47:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5618,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17839:47:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5619,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5594,
+                                        "src": "17903:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5601,
+                                    "id": 5620,
+                                    "nodeType": "Return",
+                                    "src": "17896:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5622,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "with_key",
+                        "nameLocation": "17744:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5597,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5594,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17772:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5622,
+                                    "src": "17753:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5593,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5592,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17753:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17753:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5596,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "17786:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5622,
+                                    "src": "17778:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5595,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17778:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17752:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5601,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5600,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5622,
+                                    "src": "17809:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5599,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5598,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17809:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17809:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17808:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17735:179:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5646,
+                            "nodeType": "Block",
+                            "src": "18014:67:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5640,
+                                                        "name": "amt",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5627,
+                                                        "src": "18048:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5639,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "18040:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5638,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "18040:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5641,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "18040:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "expression": {
+                                                    "id": 5633,
+                                                    "name": "self",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5625,
+                                                    "src": "18024:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                        "typeString": "struct StdStorage storage pointer"
+                                                    }
+                                                },
+                                                "id": 5636,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "_keys",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5024,
+                                                "src": "18024:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                    "typeString": "bytes32[] storage ref"
+                                                }
+                                            },
+                                            "id": 5637,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "push",
+                                            "nodeType": "MemberAccess",
+                                            "src": "18024:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_arraypush_nonpayable$_t_array$_t_bytes32_$dyn_storage_ptr_$_t_bytes32_$returns$__$bound_to$_t_array$_t_bytes32_$dyn_storage_ptr_$",
+                                                "typeString": "function (bytes32[] storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5642,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18024:29:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5643,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18024:29:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5644,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5625,
+                                        "src": "18070:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5632,
+                                    "id": 5645,
+                                    "nodeType": "Return",
+                                    "src": "18063:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5647,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "with_key",
+                        "nameLocation": "17929:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5628,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5625,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17957:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5647,
+                                    "src": "17938:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5624,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5623,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17938:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17938:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5627,
+                                    "mutability": "mutable",
+                                    "name": "amt",
+                                    "nameLocation": "17971:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5647,
+                                    "src": "17963:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5626,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17963:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17937:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5632,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5631,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5647,
+                                    "src": "17994:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5630,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5629,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17994:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17994:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17993:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17920:161:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5668,
+                            "nodeType": "Block",
+                            "src": "18180:58:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5663,
+                                                "name": "key",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5652,
+                                                "src": "18206:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "expression": {
+                                                    "id": 5658,
+                                                    "name": "self",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5650,
+                                                    "src": "18190:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                        "typeString": "struct StdStorage storage pointer"
+                                                    }
+                                                },
+                                                "id": 5661,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "_keys",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5024,
+                                                "src": "18190:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                    "typeString": "bytes32[] storage ref"
+                                                }
+                                            },
+                                            "id": 5662,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "push",
+                                            "nodeType": "MemberAccess",
+                                            "src": "18190:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_arraypush_nonpayable$_t_array$_t_bytes32_$dyn_storage_ptr_$_t_bytes32_$returns$__$bound_to$_t_array$_t_bytes32_$dyn_storage_ptr_$",
+                                                "typeString": "function (bytes32[] storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5664,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18190:20:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5665,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18190:20:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5666,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5650,
+                                        "src": "18227:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5657,
+                                    "id": 5667,
+                                    "nodeType": "Return",
+                                    "src": "18220:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5669,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "with_key",
+                        "nameLocation": "18095:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5653,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5650,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18123:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5669,
+                                    "src": "18104:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5649,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5648,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18104:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18104:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5652,
+                                    "mutability": "mutable",
+                                    "name": "key",
+                                    "nameLocation": "18137:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5669,
+                                    "src": "18129:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5651,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18129:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18103:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5657,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5656,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5669,
+                                    "src": "18160:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5655,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5654,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18160:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18160:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18159:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "18086:152:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5688,
+                            "nodeType": "Block",
+                            "src": "18338:58:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5684,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5680,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5672,
+                                                "src": "18348:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5682,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_depth",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5028,
+                                            "src": "18348:11:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 5683,
+                                            "name": "_depth",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5674,
+                                            "src": "18362:6:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "18348:20:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 5685,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18348:20:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5686,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5672,
+                                        "src": "18385:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5679,
+                                    "id": 5687,
+                                    "nodeType": "Return",
+                                    "src": "18378:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5689,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "depth",
+                        "nameLocation": "18253:5:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5675,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5672,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18278:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5689,
+                                    "src": "18259:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5671,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5670,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18259:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18259:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5674,
+                                    "mutability": "mutable",
+                                    "name": "_depth",
+                                    "nameLocation": "18292:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5689,
+                                    "src": "18284:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5673,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18284:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18258:41:6"
+                        },
+                        "returnParameters": {
+                            "id": 5679,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5678,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5689,
+                                    "src": "18318:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5677,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5676,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18318:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18318:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18317:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "18244:152:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5711,
+                            "nodeType": "Block",
+                            "src": "18472:68:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5698,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5692,
+                                                "src": "18496:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5705,
+                                                                        "name": "who",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5694,
+                                                                        "src": "18526:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "id": 5704,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                                    "src": "18518:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_type$_t_uint160_$",
+                                                                        "typeString": "type(uint160)"
+                                                                    },
+                                                                    "typeName": {
+                                                                        "id": 5703,
+                                                                        "name": "uint160",
+                                                                        "nodeType": "ElementaryTypeName",
+                                                                        "src": "18518:7:6",
+                                                                        "typeDescriptions": {}
+                                                                    }
+                                                                },
+                                                                "id": 5706,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "typeConversion",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "18518:12:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            ],
+                                                            "id": 5702,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "18510:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5701,
+                                                                "name": "uint256",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "18510:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5707,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "18510:21:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5700,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "18502:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5699,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "18502:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5708,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "18502:30:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5697,
+                                            "name": "checked_write",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                5712, 5729, 5747, 5892
+                                            ],
+                                            "referencedDeclaration": 5892,
+                                            "src": "18482:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (struct StdStorage storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5709,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18482:51:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5710,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18482:51:6"
+                                }
+                            ]
+                        },
+                        "id": 5712,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18411:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5695,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5692,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18444:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5712,
+                                    "src": "18425:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5691,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5690,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18425:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18425:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5694,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "18458:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5712,
+                                    "src": "18450:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5693,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18450:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18424:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5696,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18472:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18402:138:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5728,
+                            "nodeType": "Block",
+                            "src": "18616:50:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5721,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5715,
+                                                "src": "18640:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5724,
+                                                        "name": "amt",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5717,
+                                                        "src": "18654:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5723,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "18646:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5722,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "18646:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5725,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "18646:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5720,
+                                            "name": "checked_write",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                5712, 5729, 5747, 5892
+                                            ],
+                                            "referencedDeclaration": 5892,
+                                            "src": "18626:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (struct StdStorage storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5726,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18626:33:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5727,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18626:33:6"
+                                }
+                            ]
+                        },
+                        "id": 5729,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18555:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5718,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5715,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18588:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5729,
+                                    "src": "18569:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5714,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5713,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18569:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18569:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5717,
+                                    "mutability": "mutable",
+                                    "name": "amt",
+                                    "nameLocation": "18602:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5729,
+                                    "src": "18594:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5716,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18594:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18568:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5719,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18616:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18546:120:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5746,
+                            "nodeType": "Block",
+                            "src": "18741:153:6",
+                            "statements": [
+                                {
+                                    "assignments": [5738],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5738,
+                                            "mutability": "mutable",
+                                            "name": "t",
+                                            "nameLocation": "18759:1:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5746,
+                                            "src": "18751:9:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5737,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "18751:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5739,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "18751:9:6"
+                                },
+                                {
+                                    "AST": {
+                                        "nodeType": "YulBlock",
+                                        "src": "18822:34:6",
+                                        "statements": [
+                                            {
+                                                "nodeType": "YulAssignment",
+                                                "src": "18836:10:6",
+                                                "value": {
+                                                    "name": "write",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "18841:5:6"
+                                                },
+                                                "variableNames": [
+                                                    {
+                                                        "name": "t",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "18836:1:6"
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    },
+                                    "documentation": "@solidity memory-safe-assembly",
+                                    "evmVersion": "london",
+                                    "externalReferences": [
+                                        {
+                                            "declaration": 5738,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "18836:1:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 5734,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "18841:5:6",
+                                            "valueSize": 1
+                                        }
+                                    ],
+                                    "id": 5740,
+                                    "nodeType": "InlineAssembly",
+                                    "src": "18813:43:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5742,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5732,
+                                                "src": "18879:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            {
+                                                "id": 5743,
+                                                "name": "t",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5738,
+                                                "src": "18885:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5741,
+                                            "name": "checked_write",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                5712, 5729, 5747, 5892
+                                            ],
+                                            "referencedDeclaration": 5892,
+                                            "src": "18865:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (struct StdStorage storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5744,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18865:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5745,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18865:22:6"
+                                }
+                            ]
+                        },
+                        "id": 5747,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18681:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5735,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5732,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18714:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5747,
+                                    "src": "18695:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5731,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5730,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18695:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18695:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5734,
+                                    "mutability": "mutable",
+                                    "name": "write",
+                                    "nameLocation": "18725:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5747,
+                                    "src": "18720:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 5733,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18720:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18694:37:6"
+                        },
+                        "returnParameters": {
+                            "id": 5736,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18741:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18672:222:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5891,
+                            "nodeType": "Block",
+                            "src": "18992:966:6",
+                            "statements": [
+                                {
+                                    "assignments": [5756],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5756,
+                                            "mutability": "mutable",
+                                            "name": "who",
+                                            "nameLocation": "19010:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19002:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            },
+                                            "typeName": {
+                                                "id": 5755,
+                                                "name": "address",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19002:7:6",
+                                                "stateMutability": "nonpayable",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5759,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5757,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19016:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5758,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_target",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5030,
+                                        "src": "19016:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19002:26:6"
+                                },
+                                {
+                                    "assignments": [5761],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5761,
+                                            "mutability": "mutable",
+                                            "name": "fsig",
+                                            "nameLocation": "19045:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19038:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            },
+                                            "typeName": {
+                                                "id": 5760,
+                                                "name": "bytes4",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19038:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5764,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5762,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19052:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5763,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_sig",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5026,
+                                        "src": "19052:9:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19038:23:6"
+                                },
+                                {
+                                    "assignments": [5766],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5766,
+                                            "mutability": "mutable",
+                                            "name": "field_depth",
+                                            "nameLocation": "19079:11:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19071:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 5765,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19071:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5769,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5767,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19093:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5768,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_depth",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5028,
+                                        "src": "19093:11:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19071:33:6"
+                                },
+                                {
+                                    "assignments": [5774],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5774,
+                                            "mutability": "mutable",
+                                            "name": "ins",
+                                            "nameLocation": "19131:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19114:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                "typeString": "bytes32[]"
+                                            },
+                                            "typeName": {
+                                                "baseType": {
+                                                    "id": 5772,
+                                                    "name": "bytes32",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "19114:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5773,
+                                                "nodeType": "ArrayTypeName",
+                                                "src": "19114:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                                    "typeString": "bytes32[]"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5777,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5775,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19137:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5776,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_keys",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5024,
+                                        "src": "19137:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                            "typeString": "bytes32[] storage ref"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19114:33:6"
+                                },
+                                {
+                                    "assignments": [5779],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5779,
+                                            "mutability": "mutable",
+                                            "name": "cald",
+                                            "nameLocation": "19171:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19158:17:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 5778,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19158:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5787,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 5782,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5761,
+                                                "src": "19195:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5784,
+                                                        "name": "ins",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5774,
+                                                        "src": "19209:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    ],
+                                                    "id": 5783,
+                                                    "name": "flatten",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5989,
+                                                    "src": "19201:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_pure$_t_array$_t_bytes32_$dyn_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes32[] memory) pure returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5785,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "19201:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5780,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "19178:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 5781,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "encodePacked",
+                                            "nodeType": "MemberAccess",
+                                            "src": "19178:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function () pure returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 5786,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19178:36:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19158:56:6"
+                                },
+                                {
+                                    "condition": {
+                                        "id": 5802,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "!",
+                                        "prefix": true,
+                                        "src": "19228:69:6",
+                                        "subExpression": {
+                                            "baseExpression": {
+                                                "baseExpression": {
+                                                    "baseExpression": {
+                                                        "expression": {
+                                                            "id": 5788,
+                                                            "name": "self",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5750,
+                                                            "src": "19229:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        },
+                                                        "id": 5789,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "finds",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 5021,
+                                                        "src": "19229:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                            "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                        }
+                                                    },
+                                                    "id": 5791,
+                                                    "indexExpression": {
+                                                        "id": 5790,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5756,
+                                                        "src": "19240:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "19229:15:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                        "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                    }
+                                                },
+                                                "id": 5793,
+                                                "indexExpression": {
+                                                    "id": 5792,
+                                                    "name": "fsig",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5761,
+                                                    "src": "19245:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes4",
+                                                        "typeString": "bytes4"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "19229:21:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                    "typeString": "mapping(bytes32 => bool)"
+                                                }
+                                            },
+                                            "id": 5801,
+                                            "indexExpression": {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "id": 5797,
+                                                                "name": "ins",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5774,
+                                                                "src": "19278:3:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                }
+                                                            },
+                                                            {
+                                                                "id": 5798,
+                                                                "name": "field_depth",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5766,
+                                                                "src": "19283:11:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                },
+                                                                {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "id": 5795,
+                                                                "name": "abi",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -1,
+                                                                "src": "19261:3:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_magic_abi",
+                                                                    "typeString": "abi"
+                                                                }
+                                                            },
+                                                            "id": 5796,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "memberName": "encodePacked",
+                                                            "nodeType": "MemberAccess",
+                                                            "src": "19261:16:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                "typeString": "function () pure returns (bytes memory)"
+                                                            }
+                                                        },
+                                                        "id": 5799,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "19261:34:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "id": 5794,
+                                                    "name": "keccak256",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": -8,
+                                                    "src": "19251:9:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                        "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                    }
+                                                },
+                                                "id": 5800,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "19251:45:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "IndexAccess",
+                                            "src": "19229:68:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5808,
+                                    "nodeType": "IfStatement",
+                                    "src": "19224:110:6",
+                                    "trueBody": {
+                                        "id": 5807,
+                                        "nodeType": "Block",
+                                        "src": "19299:35:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5804,
+                                                            "name": "self",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5750,
+                                                            "src": "19318:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        ],
+                                                        "id": 5803,
+                                                        "name": "find",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5529,
+                                                        "src": "19313:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$returns$_t_uint256_$",
+                                                            "typeString": "function (struct StdStorage storage pointer) returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 5805,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19313:10:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 5806,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "19313:10:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "assignments": [5810],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5810,
+                                            "mutability": "mutable",
+                                            "name": "slot",
+                                            "nameLocation": "19351:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19343:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5809,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19343:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5828,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "baseExpression": {
+                                                    "baseExpression": {
+                                                        "baseExpression": {
+                                                            "expression": {
+                                                                "id": 5813,
+                                                                "name": "self",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5750,
+                                                                "src": "19366:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 5814,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "slots",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5013,
+                                                            "src": "19366:10:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                            }
+                                                        },
+                                                        "id": 5816,
+                                                        "indexExpression": {
+                                                            "id": 5815,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5756,
+                                                            "src": "19377:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "19366:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                            "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                        }
+                                                    },
+                                                    "id": 5818,
+                                                    "indexExpression": {
+                                                        "id": 5817,
+                                                        "name": "fsig",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5761,
+                                                        "src": "19382:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes4",
+                                                            "typeString": "bytes4"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "19366:21:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                        "typeString": "mapping(bytes32 => uint256)"
+                                                    }
+                                                },
+                                                "id": 5826,
+                                                "indexExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "id": 5822,
+                                                                    "name": "ins",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5774,
+                                                                    "src": "19415:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    }
+                                                                },
+                                                                {
+                                                                    "id": 5823,
+                                                                    "name": "field_depth",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5766,
+                                                                    "src": "19420:11:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    },
+                                                                    {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "id": 5820,
+                                                                    "name": "abi",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": -1,
+                                                                    "src": "19398:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_magic_abi",
+                                                                        "typeString": "abi"
+                                                                    }
+                                                                },
+                                                                "id": 5821,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "memberName": "encodePacked",
+                                                                "nodeType": "MemberAccess",
+                                                                "src": "19398:16:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                    "typeString": "function () pure returns (bytes memory)"
+                                                                }
+                                                            },
+                                                            "id": 5824,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "19398:34:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 5819,
+                                                        "name": "keccak256",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -8,
+                                                        "src": "19388:9:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5825,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19388:45:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "19366:68:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "id": 5812,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "nodeType": "ElementaryTypeNameExpression",
+                                            "src": "19358:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_type$_t_bytes32_$",
+                                                "typeString": "type(bytes32)"
+                                            },
+                                            "typeName": {
+                                                "id": 5811,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19358:7:6",
+                                                "typeDescriptions": {}
+                                            }
+                                        },
+                                        "id": 5827,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "typeConversion",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19358:77:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19343:92:6"
+                                },
+                                {
+                                    "assignments": [5830],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5830,
+                                            "mutability": "mutable",
+                                            "name": "fdat",
+                                            "nameLocation": "19454:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19446:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5829,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19446:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5831,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19446:12:6"
+                                },
+                                {
+                                    "id": 5848,
+                                    "nodeType": "Block",
+                                    "src": "19468:126:6",
+                                    "statements": [
+                                        {
+                                            "assignments": [null, 5833],
+                                            "declarations": [
+                                                null,
+                                                {
+                                                    "constant": false,
+                                                    "id": 5833,
+                                                    "mutability": "mutable",
+                                                    "name": "rdat",
+                                                    "nameLocation": "19498:4:6",
+                                                    "nodeType": "VariableDeclaration",
+                                                    "scope": 5848,
+                                                    "src": "19485:17:6",
+                                                    "stateVariable": false,
+                                                    "storageLocation": "memory",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5832,
+                                                        "name": "bytes",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "19485:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                                            "typeString": "bytes"
+                                                        }
+                                                    },
+                                                    "visibility": "internal"
+                                                }
+                                            ],
+                                            "id": 5838,
+                                            "initialValue": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5836,
+                                                        "name": "cald",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5779,
+                                                        "src": "19521:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 5834,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5756,
+                                                        "src": "19506:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    },
+                                                    "id": 5835,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "staticcall",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "19506:14:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes memory) view returns (bool,bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5837,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "19506:20:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                    "typeString": "tuple(bool,bytes memory)"
+                                                }
+                                            },
+                                            "nodeType": "VariableDeclarationStatement",
+                                            "src": "19482:44:6"
+                                        },
+                                        {
+                                            "expression": {
+                                                "id": 5846,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftHandSide": {
+                                                    "id": 5839,
+                                                    "name": "fdat",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5830,
+                                                    "src": "19540:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "Assignment",
+                                                "operator": "=",
+                                                "rightHandSide": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5841,
+                                                            "name": "rdat",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5833,
+                                                            "src": "19562:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "commonType": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            "id": 5844,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "leftExpression": {
+                                                                "hexValue": "3332",
+                                                                "id": 5842,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "19568:2:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_32_by_1",
+                                                                    "typeString": "int_const 32"
+                                                                },
+                                                                "value": "32"
+                                                            },
+                                                            "nodeType": "BinaryOperation",
+                                                            "operator": "*",
+                                                            "rightExpression": {
+                                                                "id": 5843,
+                                                                "name": "field_depth",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5766,
+                                                                "src": "19571:11:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "src": "19568:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 5840,
+                                                        "name": "bytesToBytes32",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5948,
+                                                        "src": "19547:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_pure$_t_bytes_memory_ptr_$_t_uint256_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory,uint256) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5845,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19547:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "src": "19540:43:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "id": 5847,
+                                            "nodeType": "ExpressionStatement",
+                                            "src": "19540:43:6"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "assignments": [5850],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5850,
+                                            "mutability": "mutable",
+                                            "name": "curr",
+                                            "nameLocation": "19611:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19603:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5849,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19603:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5856,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 5853,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5756,
+                                                "src": "19636:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 5854,
+                                                "name": "slot",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5810,
+                                                "src": "19641:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5851,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "19618:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5852,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "load",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6022,
+                                            "src": "19618:17:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$returns$_t_bytes32_$",
+                                                "typeString": "function (address,bytes32) external returns (bytes32)"
+                                            }
+                                        },
+                                        "id": 5855,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19618:28:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19603:43:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        },
+                                        "id": 5859,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 5857,
+                                            "name": "fdat",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5830,
+                                            "src": "19661:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "id": 5858,
+                                            "name": "curr",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5850,
+                                            "src": "19669:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "src": "19661:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5866,
+                                    "nodeType": "IfStatement",
+                                    "src": "19657:141:6",
+                                    "trueBody": {
+                                        "id": 5865,
+                                        "nodeType": "Block",
+                                        "src": "19675:123:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "66616c7365",
+                                                            "id": 5861,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "bool",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "19697:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bool",
+                                                                "typeString": "bool"
+                                                            },
+                                                            "value": "false"
+                                                        },
+                                                        {
+                                                            "hexValue": "5061636b656420736c6f742e205468697320776f756c642063617573652064616e6765726f7573206f76657277726974696e6720616e642063757272656e746c792069736e7420737570706f72746564",
+                                                            "id": 5862,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "19704:82:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                            },
+                                                            "value": "Packed slot. This would cause dangerous overwriting and currently isnt supported"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bool",
+                                                                "typeString": "bool"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                            }
+                                                        ],
+                                                        "id": 5860,
+                                                        "name": "require",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [
+                                                            -18, -18
+                                                        ],
+                                                        "referencedDeclaration": -18,
+                                                        "src": "19689:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (bool,string memory) pure"
+                                                        }
+                                                    },
+                                                    "id": 5863,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19689:98:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 5864,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "19689:98:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5870,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5756,
+                                                "src": "19826:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 5871,
+                                                "name": "slot",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5810,
+                                                "src": "19831:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            {
+                                                "id": 5872,
+                                                "name": "set",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5752,
+                                                "src": "19837:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5867,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "19807:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5869,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "store",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6031,
+                                            "src": "19807:18:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (address,bytes32,bytes32) external"
+                                            }
+                                        },
+                                        "id": 5873,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19807:34:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5874,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19807:34:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5877,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19851:19:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5875,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19858:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5876,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_target",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5030,
+                                            "src": "19858:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5878,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19851:19:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5881,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19880:16:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5879,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19887:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5880,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "19887:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5882,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19880:16:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5885,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19906:17:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5883,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19913:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5884,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_keys",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5024,
+                                            "src": "19913:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                "typeString": "bytes32[] storage ref"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5886,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19906:17:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5889,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19933:18:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5887,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19940:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5888,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_depth",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5028,
+                                            "src": "19940:11:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5890,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19933:18:6"
+                                }
+                            ]
+                        },
+                        "id": 5892,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18909:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5753,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5750,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18951:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5892,
+                                    "src": "18932:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5749,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5748,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18932:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18932:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5752,
+                                    "mutability": "mutable",
+                                    "name": "set",
+                                    "nameLocation": "18973:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5892,
+                                    "src": "18965:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5751,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18965:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18922:60:6"
+                        },
+                        "returnParameters": {
+                            "id": 5754,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18992:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18900:1058:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5947,
+                            "nodeType": "Block",
+                            "src": "20047:214:6",
+                            "statements": [
+                                {
+                                    "assignments": [5902],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5902,
+                                            "mutability": "mutable",
+                                            "name": "out",
+                                            "nameLocation": "20065:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5947,
+                                            "src": "20057:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5901,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20057:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5903,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "20057:11:6"
+                                },
+                                {
+                                    "assignments": [5905],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5905,
+                                            "mutability": "mutable",
+                                            "name": "max",
+                                            "nameLocation": "20087:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5947,
+                                            "src": "20079:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 5904,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20079:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5914,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 5909,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "expression": {
+                                                    "id": 5906,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5894,
+                                                    "src": "20093:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                },
+                                                "id": 5907,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "length",
+                                                "nodeType": "MemberAccess",
+                                                "src": "20093:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "hexValue": "3332",
+                                                "id": 5908,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "20104:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_32_by_1",
+                                                    "typeString": "int_const 32"
+                                                },
+                                                "value": "32"
+                                            },
+                                            "src": "20093:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "expression": {
+                                                "id": 5911,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5894,
+                                                "src": "20114:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            },
+                                            "id": 5912,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "length",
+                                            "nodeType": "MemberAccess",
+                                            "src": "20114:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 5913,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "20093:29:6",
+                                        "trueExpression": {
+                                            "hexValue": "3332",
+                                            "id": 5910,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "20109:2:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_32_by_1",
+                                                "typeString": "int_const 32"
+                                            },
+                                            "value": "32"
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "20079:43:6"
+                                },
+                                {
+                                    "body": {
+                                        "id": 5943,
+                                        "nodeType": "Block",
+                                        "src": "20163:72:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "id": 5941,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "id": 5925,
+                                                        "name": "out",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5902,
+                                                        "src": "20177:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "|=",
+                                                    "rightHandSide": {
+                                                        "commonType": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        },
+                                                        "id": 5940,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "leftExpression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_bytes1",
+                                                                        "typeString": "bytes1"
+                                                                    },
+                                                                    "id": 5934,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "baseExpression": {
+                                                                            "id": 5928,
+                                                                            "name": "b",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5894,
+                                                                            "src": "20192:1:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                "typeString": "bytes memory"
+                                                                            }
+                                                                        },
+                                                                        "id": 5932,
+                                                                        "indexExpression": {
+                                                                            "commonType": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            },
+                                                                            "id": 5931,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftExpression": {
+                                                                                "id": 5929,
+                                                                                "name": "offset",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5896,
+                                                                                "src": "20194:6:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "BinaryOperation",
+                                                                            "operator": "+",
+                                                                            "rightExpression": {
+                                                                                "id": 5930,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5916,
+                                                                                "src": "20203:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "src": "20194:10:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        },
+                                                                        "isConstant": false,
+                                                                        "isLValue": true,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "IndexAccess",
+                                                                        "src": "20192:13:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes1",
+                                                                            "typeString": "bytes1"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "&",
+                                                                    "rightExpression": {
+                                                                        "hexValue": "30784646",
+                                                                        "id": 5933,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "number",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "20208:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_rational_255_by_1",
+                                                                            "typeString": "int_const 255"
+                                                                        },
+                                                                        "value": "0xFF"
+                                                                    },
+                                                                    "src": "20192:20:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes1",
+                                                                        "typeString": "bytes1"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes1",
+                                                                        "typeString": "bytes1"
+                                                                    }
+                                                                ],
+                                                                "id": 5927,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "20184:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                    "typeString": "type(bytes32)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 5926,
+                                                                    "name": "bytes32",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "20184:7:6",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 5935,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "20184:29:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "nodeType": "BinaryOperation",
+                                                        "operator": ">>",
+                                                        "rightExpression": {
+                                                            "components": [
+                                                                {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 5938,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 5936,
+                                                                        "name": "i",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5916,
+                                                                        "src": "20218:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "*",
+                                                                    "rightExpression": {
+                                                                        "hexValue": "38",
+                                                                        "id": 5937,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "number",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "20222:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_rational_8_by_1",
+                                                                            "typeString": "int_const 8"
+                                                                        },
+                                                                        "value": "8"
+                                                                    },
+                                                                    "src": "20218:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "id": 5939,
+                                                            "isConstant": false,
+                                                            "isInlineArray": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "TupleExpression",
+                                                            "src": "20217:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "src": "20184:40:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "src": "20177:47:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5942,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "20177:47:6"
+                                            }
+                                        ]
+                                    },
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 5921,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 5919,
+                                            "name": "i",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5916,
+                                            "src": "20149:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "<",
+                                        "rightExpression": {
+                                            "id": 5920,
+                                            "name": "max",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5905,
+                                            "src": "20153:3:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "20149:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5944,
+                                    "initializationExpression": {
+                                        "assignments": [5916],
+                                        "declarations": [
+                                            {
+                                                "constant": false,
+                                                "id": 5916,
+                                                "mutability": "mutable",
+                                                "name": "i",
+                                                "nameLocation": "20142:1:6",
+                                                "nodeType": "VariableDeclaration",
+                                                "scope": 5944,
+                                                "src": "20137:6:6",
+                                                "stateVariable": false,
+                                                "storageLocation": "default",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "typeName": {
+                                                    "id": 5915,
+                                                    "name": "uint",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "20137:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "visibility": "internal"
+                                            }
+                                        ],
+                                        "id": 5918,
+                                        "initialValue": {
+                                            "hexValue": "30",
+                                            "id": 5917,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "20146:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "nodeType": "VariableDeclarationStatement",
+                                        "src": "20137:10:6"
+                                    },
+                                    "loopExpression": {
+                                        "expression": {
+                                            "id": 5923,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "UnaryOperation",
+                                            "operator": "++",
+                                            "prefix": false,
+                                            "src": "20158:3:6",
+                                            "subExpression": {
+                                                "id": 5922,
+                                                "name": "i",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5916,
+                                                "src": "20158:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 5924,
+                                        "nodeType": "ExpressionStatement",
+                                        "src": "20158:3:6"
+                                    },
+                                    "nodeType": "ForStatement",
+                                    "src": "20132:103:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5945,
+                                        "name": "out",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5902,
+                                        "src": "20251:3:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5900,
+                                    "id": 5946,
+                                    "nodeType": "Return",
+                                    "src": "20244:10:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "53584939",
+                        "id": 5948,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "bytesToBytes32",
+                        "nameLocation": "19973:14:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5897,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5894,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "20001:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5948,
+                                    "src": "19988:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 5893,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "19988:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5896,
+                                    "mutability": "mutable",
+                                    "name": "offset",
+                                    "nameLocation": "20009:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5948,
+                                    "src": "20004:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5895,
+                                        "name": "uint",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "20004:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "19987:29:6"
+                        },
+                        "returnParameters": {
+                            "id": 5900,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5899,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5948,
+                                    "src": "20038:7:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5898,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "20038:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "20037:9:6"
+                        },
+                        "scope": 5990,
+                        "src": "19964:297:6",
+                        "stateMutability": "pure",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 5988,
+                            "nodeType": "Block",
+                            "src": "20344:320:6",
+                            "statements": [
+                                {
+                                    "assignments": [5957],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5957,
+                                            "mutability": "mutable",
+                                            "name": "result",
+                                            "nameLocation": "20367:6:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5988,
+                                            "src": "20354:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 5956,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20354:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5965,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 5963,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 5960,
+                                                        "name": "b",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5951,
+                                                        "src": "20386:1:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    },
+                                                    "id": 5961,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "length",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "20386:8:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "*",
+                                                "rightExpression": {
+                                                    "hexValue": "3332",
+                                                    "id": 5962,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "20397:2:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_32_by_1",
+                                                        "typeString": "int_const 32"
+                                                    },
+                                                    "value": "32"
+                                                },
+                                                "src": "20386:13:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "id": 5959,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "nodeType": "NewExpression",
+                                            "src": "20376:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_objectcreation_pure$_t_uint256_$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function (uint256) pure returns (bytes memory)"
+                                            },
+                                            "typeName": {
+                                                "id": 5958,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20380:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            }
+                                        },
+                                        "id": 5964,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "20376:24:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "20354:46:6"
+                                },
+                                {
+                                    "body": {
+                                        "id": 5984,
+                                        "nodeType": "Block",
+                                        "src": "20449:185:6",
+                                        "statements": [
+                                            {
+                                                "assignments": [5978],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 5978,
+                                                        "mutability": "mutable",
+                                                        "name": "k",
+                                                        "nameLocation": "20471:1:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 5984,
+                                                        "src": "20463:9:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 5977,
+                                                            "name": "bytes32",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "20463:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 5982,
+                                                "initialValue": {
+                                                    "baseExpression": {
+                                                        "id": 5979,
+                                                        "name": "b",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5951,
+                                                        "src": "20475:1:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    },
+                                                    "id": 5981,
+                                                    "indexExpression": {
+                                                        "id": 5980,
+                                                        "name": "i",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5967,
+                                                        "src": "20477:1:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "20475:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "20463:16:6"
+                                            },
+                                            {
+                                                "AST": {
+                                                    "nodeType": "YulBlock",
+                                                    "src": "20549:75:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "arguments": [
+                                                                            {
+                                                                                "name": "result",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "20578:6:6"
+                                                                            },
+                                                                            {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "kind": "number",
+                                                                                        "nodeType": "YulLiteral",
+                                                                                        "src": "20590:2:6",
+                                                                                        "type": "",
+                                                                                        "value": "32"
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "kind": "number",
+                                                                                                "nodeType": "YulLiteral",
+                                                                                                "src": "20598:2:6",
+                                                                                                "type": "",
+                                                                                                "value": "32"
+                                                                                            },
+                                                                                            {
+                                                                                                "name": "i",
+                                                                                                "nodeType": "YulIdentifier",
+                                                                                                "src": "20602:1:6"
+                                                                                            }
+                                                                                        ],
+                                                                                        "functionName": {
+                                                                                            "name": "mul",
+                                                                                            "nodeType": "YulIdentifier",
+                                                                                            "src": "20594:3:6"
+                                                                                        },
+                                                                                        "nodeType": "YulFunctionCall",
+                                                                                        "src": "20594:10:6"
+                                                                                    }
+                                                                                ],
+                                                                                "functionName": {
+                                                                                    "name": "add",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "20586:3:6"
+                                                                                },
+                                                                                "nodeType": "YulFunctionCall",
+                                                                                "src": "20586:19:6"
+                                                                            }
+                                                                        ],
+                                                                        "functionName": {
+                                                                            "name": "add",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "20574:3:6"
+                                                                        },
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "20574:32:6"
+                                                                    },
+                                                                    {
+                                                                        "name": "k",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "20608:1:6"
+                                                                    }
+                                                                ],
+                                                                "functionName": {
+                                                                    "name": "mstore",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "20567:6:6"
+                                                                },
+                                                                "nodeType": "YulFunctionCall",
+                                                                "src": "20567:43:6"
+                                                            },
+                                                            "nodeType": "YulExpressionStatement",
+                                                            "src": "20567:43:6"
+                                                        }
+                                                    ]
+                                                },
+                                                "documentation": "@solidity memory-safe-assembly",
+                                                "evmVersion": "london",
+                                                "externalReferences": [
+                                                    {
+                                                        "declaration": 5967,
+                                                        "isOffset": false,
+                                                        "isSlot": false,
+                                                        "src": "20602:1:6",
+                                                        "valueSize": 1
+                                                    },
+                                                    {
+                                                        "declaration": 5978,
+                                                        "isOffset": false,
+                                                        "isSlot": false,
+                                                        "src": "20608:1:6",
+                                                        "valueSize": 1
+                                                    },
+                                                    {
+                                                        "declaration": 5957,
+                                                        "isOffset": false,
+                                                        "isSlot": false,
+                                                        "src": "20578:6:6",
+                                                        "valueSize": 1
+                                                    }
+                                                ],
+                                                "id": 5983,
+                                                "nodeType": "InlineAssembly",
+                                                "src": "20540:84:6"
+                                            }
+                                        ]
+                                    },
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 5973,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 5970,
+                                            "name": "i",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5967,
+                                            "src": "20430:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "<",
+                                        "rightExpression": {
+                                            "expression": {
+                                                "id": 5971,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5951,
+                                                "src": "20434:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                    "typeString": "bytes32[] memory"
+                                                }
+                                            },
+                                            "id": 5972,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "length",
+                                            "nodeType": "MemberAccess",
+                                            "src": "20434:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "20430:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5985,
+                                    "initializationExpression": {
+                                        "assignments": [5967],
+                                        "declarations": [
+                                            {
+                                                "constant": false,
+                                                "id": 5967,
+                                                "mutability": "mutable",
+                                                "name": "i",
+                                                "nameLocation": "20423:1:6",
+                                                "nodeType": "VariableDeclaration",
+                                                "scope": 5985,
+                                                "src": "20415:9:6",
+                                                "stateVariable": false,
+                                                "storageLocation": "default",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "typeName": {
+                                                    "id": 5966,
+                                                    "name": "uint256",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "20415:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "visibility": "internal"
+                                            }
+                                        ],
+                                        "id": 5969,
+                                        "initialValue": {
+                                            "hexValue": "30",
+                                            "id": 5968,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "20427:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "nodeType": "VariableDeclarationStatement",
+                                        "src": "20415:13:6"
+                                    },
+                                    "loopExpression": {
+                                        "expression": {
+                                            "id": 5975,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "UnaryOperation",
+                                            "operator": "++",
+                                            "prefix": false,
+                                            "src": "20444:3:6",
+                                            "subExpression": {
+                                                "id": 5974,
+                                                "name": "i",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5967,
+                                                "src": "20444:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 5976,
+                                        "nodeType": "ExpressionStatement",
+                                        "src": "20444:3:6"
+                                    },
+                                    "nodeType": "ForStatement",
+                                    "src": "20410:224:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5986,
+                                        "name": "result",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5957,
+                                        "src": "20651:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5955,
+                                    "id": 5987,
+                                    "nodeType": "Return",
+                                    "src": "20644:13:6"
+                                }
+                            ]
+                        },
+                        "id": 5989,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "flatten",
+                        "nameLocation": "20276:7:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5952,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5951,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "20301:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5989,
+                                    "src": "20284:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                        "typeString": "bytes32[]"
+                                    },
+                                    "typeName": {
+                                        "baseType": {
+                                            "id": 5949,
+                                            "name": "bytes32",
+                                            "nodeType": "ElementaryTypeName",
+                                            "src": "20284:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "id": 5950,
+                                        "nodeType": "ArrayTypeName",
+                                        "src": "20284:9:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                            "typeString": "bytes32[]"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "20283:20:6"
+                        },
+                        "returnParameters": {
+                            "id": 5955,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5954,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5989,
+                                    "src": "20326:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 5953,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "20326:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "20325:14:6"
+                        },
+                        "scope": 5990,
+                        "src": "20267:397:6",
+                        "stateMutability": "pure",
+                        "virtual": false,
+                        "visibility": "private"
+                    }
+                ],
+                "scope": 5991,
+                "src": "13204:7462:6",
+                "usedErrors": []
+            }
+        ],
+        "src": "38:20629:6"
+    }
+}
diff --git a/out/Test.sol/stdError.json b/out/Test.sol/stdError.json
new file mode 100644
index 0000000..d3317ab
--- /dev/null
+++ b/out/Test.sol/stdError.json
@@ -0,0 +1,28796 @@
+{
+    "abi": [
+        {
+            "inputs": [],
+            "name": "arithmeticError",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "assertionError",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "divisionError",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "encodeStorageError",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "enumConversionError",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "indexOOBError",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "lowLevelError",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "memOverflowError",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "popError",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "zeroVarError",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        }
+    ],
+    "bytecode": {
+        "object": "0x61027761003a600b82828239805160001a60731461002d57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106100a85760003560e01c8063ac3d92c611610070578063ac3d92c6146100eb578063b22dc54d14610101578063b67689da14610109578063d160e4de14610111578063fa784a441461011957600080fd5b806305ee8612146100ad57806310332977146100cb5780631de45560146100d35780638995290f146100db578063986c5f68146100e3575b600080fd5b6100b5610121565b6040516100c291906101ec565b60405180910390f35b6100b561015c565b6100b561016e565b6100b5610180565b6100b5610192565b6100b56040518060200160405280600081525081565b6100b56101a4565b6100b56101b6565b6100b56101c8565b6100b56101da565b604051603260248201526044015b60408051601f198184030181529190526020810180516001600160e01b0316634e487b7160e01b17905281565b6040516001602482015260440161012f565b6040516021602482015260440161012f565b6040516011602482015260440161012f565b6040516041602482015260440161012f565b6040516031602482015260440161012f565b6040516051602482015260440161012f565b6040516022602482015260440161012f565b6040516012602482015260440161012f565b600060208083528351808285015260005b81811015610219578581018301518582016040015282016101fd565b8181111561022b576000604083870101525b50601f01601f191692909201604001939250505056fea26469706673582212200052e16a58c61a38930fdf2f389207bec9094e63fd63461b7ad40c1ad12a12fc64736f6c634300080a0033",
+        "sourceMap": "11740:986:6:-:0;;;;;;;;;;;;;;;-1:-1:-1;;;11740:986:6;;;;;;;;;;;;;;;;;",
+        "linkReferences": {}
+    },
+    "deployedBytecode": {
+        "object": "0x73000000000000000000000000000000000000000030146080604052600436106100a85760003560e01c8063ac3d92c611610070578063ac3d92c6146100eb578063b22dc54d14610101578063b67689da14610109578063d160e4de14610111578063fa784a441461011957600080fd5b806305ee8612146100ad57806310332977146100cb5780631de45560146100d35780638995290f146100db578063986c5f68146100e3575b600080fd5b6100b5610121565b6040516100c291906101ec565b60405180910390f35b6100b561015c565b6100b561016e565b6100b5610180565b6100b5610192565b6100b56040518060200160405280600081525081565b6100b56101a4565b6100b56101b6565b6100b56101c8565b6100b56101da565b604051603260248201526044015b60408051601f198184030181529190526020810180516001600160e01b0316634e487b7160e01b17905281565b6040516001602482015260440161012f565b6040516021602482015260440161012f565b6040516011602482015260440161012f565b6040516041602482015260440161012f565b6040516031602482015260440161012f565b6040516051602482015260440161012f565b6040516022602482015260440161012f565b6040516012602482015260440161012f565b600060208083528351808285015260005b81811015610219578581018301518582016040015282016101fd565b8181111561022b576000604083870101525b50601f01601f191692909201604001939250505056fea26469706673582212200052e16a58c61a38930fdf2f389207bec9094e63fd63461b7ad40c1ad12a12fc64736f6c634300080a0033",
+        "sourceMap": "11740:986:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12318:85;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11763:86;;;:::i;12039:91::-;;;:::i;11855:87::-;;;:::i;12409:88::-;;;:::i;12668:47::-;;12706:9;;;;;;;;;;;;12668:47;;12232:80;;;:::i;12503:84::-;;;:::i;12136:90::-;;;:::i;11948:85::-;;;:::i;12318:::-;12356:47;;12398:4;12356:47;;;775:36:27;748:18;;12356:47:6;;;;-1:-1:-1;;12356:47:6;;;;;;;;;;;;;;-1:-1:-1;;;;;12356:47:6;-1:-1:-1;;;12356:47:6;;;12318:85;:::o;11763:86::-;11802:47;;11844:4;11802:47;;;775:36:27;748:18;;11802:47:6;622:195:27;12039:91:6;12083:47;;12125:4;12083:47;;;775:36:27;748:18;;12083:47:6;622:195:27;11855:87:6;11895:47;;11937:4;11895:47;;;775:36:27;748:18;;11895:47:6;622:195:27;12409:88:6;12450:47;;12492:4;12450:47;;;775:36:27;748:18;;12450:47:6;622:195:27;12232:80:6;12265:47;;12307:4;12265:47;;;775:36:27;748:18;;12265:47:6;622:195:27;12503:84:6;12540:47;;12582:4;12540:47;;;775:36:27;748:18;;12540:47:6;622:195:27;12136:90:6;12179:47;;12221:4;12179:47;;;775:36:27;748:18;;12179:47:6;622:195:27;11948:85:6;11986:47;;12028:4;11986:47;;;775:36:27;748:18;;11986:47:6;622:195:27;14:603;132:4;161:2;190;179:9;172:21;222:6;216:13;265:6;260:2;249:9;245:18;238:34;290:1;300:140;314:6;311:1;308:13;300:140;;;409:14;;;405:23;;399:30;375:17;;;394:2;371:26;364:66;329:10;;300:140;;;458:6;455:1;452:13;449:91;;;528:1;523:2;514:6;503:9;499:22;495:31;488:42;449:91;-1:-1:-1;601:2:27;580:15;-1:-1:-1;;576:29:27;561:45;;;;608:2;557:54;;14:603;-1:-1:-1;;;14:603:27:o",
+        "linkReferences": {}
+    },
+    "ast": {
+        "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/Test.sol",
+        "exportedSymbols": {
+            "DSTest": [3806],
+            "StdStorage": [5033],
+            "Test": [4935],
+            "Vm": [6200],
+            "console": [14264],
+            "console2": [22328],
+            "stdError": [5005],
+            "stdStorage": [5990]
+        },
+        "id": 5991,
+        "license": "Unlicense",
+        "nodeType": "SourceUnit",
+        "nodes": [
+            {
+                "id": 3808,
+                "literals": ["solidity", ">=", "0.6", ".0", "<", "0.9", ".0"],
+                "nodeType": "PragmaDirective",
+                "src": "38:31:6"
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/Vm.sol",
+                "file": "./Vm.sol",
+                "id": 3809,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 6201,
+                "src": "71:18:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/lib/ds-test/src/test.sol",
+                "file": "../lib/ds-test/src/test.sol",
+                "id": 3810,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 3807,
+                "src": "90:37:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/console.sol",
+                "file": "./console.sol",
+                "id": 3811,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 14265,
+                "src": "128:23:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/console2.sol",
+                "file": "./console2.sol",
+                "id": 3812,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 22329,
+                "src": "152:24:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "abstract": true,
+                "baseContracts": [
+                    {
+                        "baseName": {
+                            "id": 3813,
+                            "name": "DSTest",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 3806,
+                            "src": "252:6:6"
+                        },
+                        "id": 3814,
+                        "nodeType": "InheritanceSpecifier",
+                        "src": "252:6:6"
+                    }
+                ],
+                "canonicalName": "Test",
+                "contractDependencies": [],
+                "contractKind": "contract",
+                "fullyImplemented": true,
+                "id": 4935,
+                "linearizedBaseContracts": [4935, 3806],
+                "name": "Test",
+                "nameLocation": "244:4:6",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "id": 3818,
+                        "libraryName": {
+                            "id": 3815,
+                            "name": "stdStorage",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 5990,
+                            "src": "271:10:6"
+                        },
+                        "nodeType": "UsingForDirective",
+                        "src": "265:32:6",
+                        "typeName": {
+                            "id": 3817,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 3816,
+                                "name": "StdStorage",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 5033,
+                                "src": "286:10:6"
+                            },
+                            "referencedDeclaration": 5033,
+                            "src": "286:10:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                "typeString": "struct StdStorage"
+                            }
+                        }
+                    },
+                    {
+                        "anonymous": false,
+                        "id": 3822,
+                        "name": "WARNING_Deprecated",
+                        "nameLocation": "309:18:6",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 3821,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3820,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "msg",
+                                    "nameLocation": "335:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3822,
+                                    "src": "328:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 3819,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "328:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "327:12:6"
+                        },
+                        "src": "303:37:6"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "3a768463",
+                        "id": 3828,
+                        "mutability": "constant",
+                        "name": "vm",
+                        "nameLocation": "365:2:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 4935,
+                        "src": "346:40:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_Vm_$6200",
+                            "typeString": "contract Vm"
+                        },
+                        "typeName": {
+                            "id": 3824,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 3823,
+                                "name": "Vm",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6200,
+                                "src": "346:2:6"
+                            },
+                            "referencedDeclaration": 6200,
+                            "src": "346:2:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "id": 3826,
+                                    "name": "HEVM_ADDRESS",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": 2127,
+                                    "src": "373:12:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                ],
+                                "id": 3825,
+                                "name": "Vm",
+                                "nodeType": "Identifier",
+                                "overloadedDeclarations": [],
+                                "referencedDeclaration": 6200,
+                                "src": "370:2:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_contract$_Vm_$6200_$",
+                                    "typeString": "type(contract Vm)"
+                                }
+                            },
+                            "id": 3827,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "370:16:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": false,
+                        "id": 3831,
+                        "mutability": "mutable",
+                        "name": "stdstore",
+                        "nameLocation": "412:8:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 4935,
+                        "src": "392:28:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                            "typeString": "struct StdStorage"
+                        },
+                        "typeName": {
+                            "id": 3830,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 3829,
+                                "name": "StdStorage",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 5033,
+                                "src": "392:10:6"
+                            },
+                            "referencedDeclaration": 5033,
+                            "src": "392:10:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                "typeString": "struct StdStorage"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 3845,
+                            "nodeType": "Block",
+                            "src": "743:48:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 3842,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 3839,
+                                                        "name": "block",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -4,
+                                                        "src": "761:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_magic_block",
+                                                            "typeString": "block"
+                                                        }
+                                                    },
+                                                    "id": 3840,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "timestamp",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "761:15:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "+",
+                                                "rightExpression": {
+                                                    "id": 3841,
+                                                    "name": "time",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 3833,
+                                                    "src": "779:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "761:22:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3836,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "753:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3838,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "warp",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5998,
+                                            "src": "753:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$returns$__$",
+                                                "typeString": "function (uint256) external"
+                                            }
+                                        },
+                                        "id": 3843,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "753:31:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3844,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "753:31:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "b9c071b4",
+                        "id": 3846,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "skip",
+                        "nameLocation": "717:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3834,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3833,
+                                    "mutability": "mutable",
+                                    "name": "time",
+                                    "nameLocation": "730:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3846,
+                                    "src": "722:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3832,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "722:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "721:14:6"
+                        },
+                        "returnParameters": {
+                            "id": 3835,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "743:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "708:83:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3860,
+                            "nodeType": "Block",
+                            "src": "834:48:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 3857,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 3854,
+                                                        "name": "block",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -4,
+                                                        "src": "852:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_magic_block",
+                                                            "typeString": "block"
+                                                        }
+                                                    },
+                                                    "id": 3855,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "timestamp",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "852:15:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "-",
+                                                "rightExpression": {
+                                                    "id": 3856,
+                                                    "name": "time",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 3848,
+                                                    "src": "870:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "852:22:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3851,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "844:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3853,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "warp",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5998,
+                                            "src": "844:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$returns$__$",
+                                                "typeString": "function (uint256) external"
+                                            }
+                                        },
+                                        "id": 3858,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "844:31:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3859,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "844:31:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "2d6c17a3",
+                        "id": 3861,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "rewind",
+                        "nameLocation": "806:6:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3849,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3848,
+                                    "mutability": "mutable",
+                                    "name": "time",
+                                    "nameLocation": "821:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3861,
+                                    "src": "813:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3847,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "813:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "812:14:6"
+                        },
+                        "returnParameters": {
+                            "id": 3850,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "834:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "797:85:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3881,
+                            "nodeType": "Block",
+                            "src": "979:62:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3869,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3863,
+                                                "src": "997:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 3872,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 3870,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1002:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 3871,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1007:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1002:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3866,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "989:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3868,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "989:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3873,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "989:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3874,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "989:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3878,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3863,
+                                                "src": "1030:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3875,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1021:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3877,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6078,
+                                            "src": "1021:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3879,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1021:13:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3880,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1021:13:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "233240ee",
+                        "id": 3882,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "954:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3864,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3863,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "967:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3882,
+                                    "src": "959:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3862,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "959:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "958:13:6"
+                        },
+                        "returnParameters": {
+                            "id": 3865,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "979:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "945:96:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3902,
+                            "nodeType": "Block",
+                            "src": "1095:58:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3892,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3884,
+                                                "src": "1113:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3893,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3886,
+                                                "src": "1118:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3889,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1105:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3891,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1105:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3894,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1105:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3895,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1105:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3899,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3884,
+                                                "src": "1142:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3896,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1133:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3898,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6078,
+                                            "src": "1133:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3900,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1133:13:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3901,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1133:13:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "e9a79a7b",
+                        "id": 3903,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "1056:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3887,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3884,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1069:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3903,
+                                    "src": "1061:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3883,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1061:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3886,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "1082:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3903,
+                                    "src": "1074:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3885,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1074:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1060:27:6"
+                        },
+                        "returnParameters": {
+                            "id": 3888,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1095:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1047:106:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3926,
+                            "nodeType": "Block",
+                            "src": "1209:70:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3913,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3905,
+                                                "src": "1227:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 3916,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 3914,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1232:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 3915,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1237:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1232:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3910,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1219:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3912,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1219:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3917,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1219:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3918,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1219:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3922,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3905,
+                                                "src": "1260:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3923,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3907,
+                                                "src": "1265:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3919,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1251:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3921,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6090,
+                                            "src": "1251:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 3924,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1251:21:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3925,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1251:21:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "29a9e300",
+                        "id": 3927,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "1168:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3908,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3905,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1181:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3927,
+                                    "src": "1173:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3904,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1173:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3907,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "1194:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3927,
+                                    "src": "1186:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3906,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1186:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1172:29:6"
+                        },
+                        "returnParameters": {
+                            "id": 3909,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1209:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1159:120:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3950,
+                            "nodeType": "Block",
+                            "src": "1349:66:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3939,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3929,
+                                                "src": "1367:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3940,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3933,
+                                                "src": "1372:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3936,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1359:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3938,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1359:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3941,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1359:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3942,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1359:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3946,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3929,
+                                                "src": "1396:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3947,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3931,
+                                                "src": "1401:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3943,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1387:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3945,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6090,
+                                            "src": "1387:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 3948,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1387:21:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3949,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1387:21:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "af9bbe5f",
+                        "id": 3951,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "1294:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3934,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3929,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1307:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3951,
+                                    "src": "1299:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3928,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1299:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3931,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "1320:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3951,
+                                    "src": "1312:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3930,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1312:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3933,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "1336:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3951,
+                                    "src": "1328:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3932,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1328:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1298:43:6"
+                        },
+                        "returnParameters": {
+                            "id": 3935,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1349:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1285:130:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3971,
+                            "nodeType": "Block",
+                            "src": "1525:67:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3959,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3953,
+                                                "src": "1543:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 3962,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 3960,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1548:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 3961,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1553:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1548:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3956,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1535:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3958,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1535:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3963,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1535:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3964,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1535:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3968,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3953,
+                                                "src": "1581:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3965,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1567:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3967,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6083,
+                                            "src": "1567:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3969,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1567:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3970,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1567:18:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "6f597075",
+                        "id": 3972,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1495:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3954,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3953,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1513:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3972,
+                                    "src": "1505:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3952,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1505:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1504:13:6"
+                        },
+                        "returnParameters": {
+                            "id": 3955,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1525:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1486:106:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3992,
+                            "nodeType": "Block",
+                            "src": "1651:63:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3982,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3974,
+                                                "src": "1669:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3983,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3976,
+                                                "src": "1674:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3979,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1661:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3981,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1661:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3984,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1661:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3985,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1661:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3989,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3974,
+                                                "src": "1703:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3986,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1689:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3988,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6083,
+                                            "src": "1689:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3990,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1689:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3991,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1689:18:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "108554f2",
+                        "id": 3993,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1607:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3977,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3974,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1625:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3993,
+                                    "src": "1617:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3973,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1617:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3976,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "1638:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3993,
+                                    "src": "1630:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3975,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1630:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1616:27:6"
+                        },
+                        "returnParameters": {
+                            "id": 3978,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1651:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1598:116:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4016,
+                            "nodeType": "Block",
+                            "src": "1888:75:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4003,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3995,
+                                                "src": "1906:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 4006,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 4004,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1911:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 4005,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1916:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1911:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4000,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1898:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4002,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1898:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 4007,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1898:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4008,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1898:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4012,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3995,
+                                                "src": "1944:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4013,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3997,
+                                                "src": "1949:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4009,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1930:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4011,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6097,
+                                            "src": "1930:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 4014,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1930:26:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4015,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1930:26:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "d06d8229",
+                        "id": 4017,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1842:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3998,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3995,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1860:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4017,
+                                    "src": "1852:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3994,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1852:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3997,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "1873:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4017,
+                                    "src": "1865:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3996,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1865:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1851:29:6"
+                        },
+                        "returnParameters": {
+                            "id": 3999,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1888:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1833:130:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4040,
+                            "nodeType": "Block",
+                            "src": "2038:71:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4029,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4019,
+                                                "src": "2056:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4030,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4023,
+                                                "src": "2061:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4026,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "2048:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4028,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "2048:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 4031,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2048:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4032,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2048:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4036,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4019,
+                                                "src": "2090:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4037,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4021,
+                                                "src": "2095:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4033,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "2076:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4035,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6097,
+                                            "src": "2076:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 4038,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2076:26:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4039,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2076:26:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "3bf82db1",
+                        "id": 4041,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1978:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4024,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4019,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1996:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4041,
+                                    "src": "1988:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4018,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1988:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4021,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "2009:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4041,
+                                    "src": "2001:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4020,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2001:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4023,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2025:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4041,
+                                    "src": "2017:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4022,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2017:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1987:43:6"
+                        },
+                        "returnParameters": {
+                            "id": 4025,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2038:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1969:140:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4069,
+                            "nodeType": "Block",
+                            "src": "2214:236:6",
+                            "statements": [
+                                {
+                                    "eventCall": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "54686520607469706020737464636865617420686173206265656e20646570726563617465642e2055736520606465616c6020696e73746561642e",
+                                                "id": 4051,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2248:61:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_744a6c098d7a732288220a904d49fcc88d2e3ed1ffdf88ffc87b900c86d281d4",
+                                                    "typeString": "literal_string \"The `tip` stdcheat has been deprecated. Use `deal` instead.\""
+                                                },
+                                                "value": "The `tip` stdcheat has been deprecated. Use `deal` instead."
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_744a6c098d7a732288220a904d49fcc88d2e3ed1ffdf88ffc87b900c86d281d4",
+                                                    "typeString": "literal_string \"The `tip` stdcheat has been deprecated. Use `deal` instead.\""
+                                                }
+                                            ],
+                                            "id": 4050,
+                                            "name": "WARNING_Deprecated",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 3822,
+                                            "src": "2229:18:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (string memory)"
+                                            }
+                                        },
+                                        "id": 4052,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2229:81:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4053,
+                                    "nodeType": "EmitStatement",
+                                    "src": "2224:86:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4066,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4047,
+                                                "src": "2438:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 4063,
+                                                        "name": "to",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4045,
+                                                        "src": "2407:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "30783730613038323331",
+                                                                "id": 4060,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "2373:10:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                },
+                                                                "value": "0x70a08231"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 4057,
+                                                                        "name": "token",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4043,
+                                                                        "src": "2349:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "id": 4054,
+                                                                        "name": "stdstore",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 3831,
+                                                                        "src": "2320:8:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                                                                            "typeString": "struct StdStorage storage ref"
+                                                                        }
+                                                                    },
+                                                                    "id": 4056,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "target",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5549,
+                                                                    "src": "2320:28:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                                    }
+                                                                },
+                                                                "id": 4058,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "2320:35:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 4059,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "sig",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5569,
+                                                            "src": "2320:52:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes4_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                "typeString": "function (struct StdStorage storage pointer,bytes4) returns (struct StdStorage storage pointer)"
+                                                            }
+                                                        },
+                                                        "id": 4061,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "2320:64:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 4062,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "with_key",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5622,
+                                                    "src": "2320:86:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                    }
+                                                },
+                                                "id": 4064,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2320:90:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 4065,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "checked_write",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5729,
+                                            "src": "2320:117:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_uint256_$returns$__$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                "typeString": "function (struct StdStorage storage pointer,uint256)"
+                                            }
+                                        },
+                                        "id": 4067,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2320:123:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4068,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2320:123:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "d82555f1",
+                        "id": 4070,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "tip",
+                        "nameLocation": "2162:3:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4048,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4043,
+                                    "mutability": "mutable",
+                                    "name": "token",
+                                    "nameLocation": "2174:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4070,
+                                    "src": "2166:13:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4042,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2166:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4045,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2189:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4070,
+                                    "src": "2181:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4044,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2181:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4047,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2201:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4070,
+                                    "src": "2193:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4046,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2193:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2165:41:6"
+                        },
+                        "returnParameters": {
+                            "id": 4049,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2214:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2153:297:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4084,
+                            "nodeType": "Block",
+                            "src": "2590:34:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4080,
+                                                "name": "to",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4072,
+                                                "src": "2608:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4081,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4074,
+                                                "src": "2612:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4077,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "2600:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4079,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "2600:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 4082,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2600:17:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4083,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2600:17:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "c88a5e6d",
+                        "id": 4085,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deal",
+                        "nameLocation": "2552:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4075,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4072,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2565:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4085,
+                                    "src": "2557:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4071,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2557:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4074,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2577:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4085,
+                                    "src": "2569:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4073,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2569:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2556:26:6"
+                        },
+                        "returnParameters": {
+                            "id": 4076,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2590:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2543:81:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4101,
+                            "nodeType": "Block",
+                            "src": "2810:45:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4095,
+                                                "name": "token",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4087,
+                                                "src": "2825:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4096,
+                                                "name": "to",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4089,
+                                                "src": "2832:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4097,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4091,
+                                                "src": "2836:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "66616c7365",
+                                                "id": 4098,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2842:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "false"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 4094,
+                                            "name": "deal",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                4085, 4102, 4205
+                                            ],
+                                            "referencedDeclaration": 4205,
+                                            "src": "2820:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$_t_bool_$returns$__$",
+                                                "typeString": "function (address,address,uint256,bool)"
+                                            }
+                                        },
+                                        "id": 4099,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2820:28:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4100,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2820:28:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "6bce989b",
+                        "id": 4102,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deal",
+                        "nameLocation": "2757:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4092,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4087,
+                                    "mutability": "mutable",
+                                    "name": "token",
+                                    "nameLocation": "2770:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4102,
+                                    "src": "2762:13:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4086,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2762:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4089,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2785:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4102,
+                                    "src": "2777:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4088,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2777:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4091,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2797:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4102,
+                                    "src": "2789:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4090,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2789:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2761:41:6"
+                        },
+                        "returnParameters": {
+                            "id": 4093,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2810:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2748:107:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4204,
+                            "nodeType": "Block",
+                            "src": "2936:840:6",
+                            "statements": [
+                                {
+                                    "assignments": [null, 4114],
+                                    "declarations": [
+                                        null,
+                                        {
+                                            "constant": false,
+                                            "id": 4114,
+                                            "mutability": "mutable",
+                                            "name": "balData",
+                                            "nameLocation": "2993:7:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4204,
+                                            "src": "2980:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 4113,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "2980:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4123,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "30783730613038323331",
+                                                        "id": 4119,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "3038:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1889567281_by_1",
+                                                            "typeString": "int_const 1889567281"
+                                                        },
+                                                        "value": "0x70a08231"
+                                                    },
+                                                    {
+                                                        "id": 4120,
+                                                        "name": "to",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4106,
+                                                        "src": "3050:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_rational_1889567281_by_1",
+                                                            "typeString": "int_const 1889567281"
+                                                        },
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 4117,
+                                                        "name": "abi",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -1,
+                                                        "src": "3015:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_magic_abi",
+                                                            "typeString": "abi"
+                                                        }
+                                                    },
+                                                    "id": 4118,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "memberName": "encodeWithSelector",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "3015:22:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_abiencodewithselector_pure$_t_bytes4_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes4) pure returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 4121,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3015:38:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4115,
+                                                "name": "token",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4104,
+                                                "src": "3004:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            "id": 4116,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "call",
+                                            "nodeType": "MemberAccess",
+                                            "src": "3004:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_barecall_payable$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                "typeString": "function (bytes memory) payable returns (bool,bytes memory)"
+                                            }
+                                        },
+                                        "id": 4122,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3004:50:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                            "typeString": "tuple(bool,bytes memory)"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "2977:77:6"
+                                },
+                                {
+                                    "assignments": [4125],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4125,
+                                            "mutability": "mutable",
+                                            "name": "prevBal",
+                                            "nameLocation": "3072:7:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4204,
+                                            "src": "3064:15:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4124,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "3064:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4133,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 4128,
+                                                "name": "balData",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4114,
+                                                "src": "3093:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            },
+                                            {
+                                                "components": [
+                                                    {
+                                                        "id": 4130,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "3103:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_uint256_$",
+                                                            "typeString": "type(uint256)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 4129,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "3103:7:6",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    }
+                                                ],
+                                                "id": 4131,
+                                                "isConstant": false,
+                                                "isInlineArray": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "nodeType": "TupleExpression",
+                                                "src": "3102:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_uint256_$",
+                                                    "typeString": "type(uint256)"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_type$_t_uint256_$",
+                                                    "typeString": "type(uint256)"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4126,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "3082:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 4127,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "decode",
+                                            "nodeType": "MemberAccess",
+                                            "src": "3082:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abidecode_pure$__$returns$__$",
+                                                "typeString": "function () pure"
+                                            }
+                                        },
+                                        "id": 4132,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3082:30:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "3064:48:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4146,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4108,
+                                                "src": "3267:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 4143,
+                                                        "name": "to",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4106,
+                                                        "src": "3236:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "30783730613038323331",
+                                                                "id": 4140,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "3202:10:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                },
+                                                                "value": "0x70a08231"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 4137,
+                                                                        "name": "token",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4104,
+                                                                        "src": "3178:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "id": 4134,
+                                                                        "name": "stdstore",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 3831,
+                                                                        "src": "3149:8:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                                                                            "typeString": "struct StdStorage storage ref"
+                                                                        }
+                                                                    },
+                                                                    "id": 4136,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "target",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5549,
+                                                                    "src": "3149:28:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                                    }
+                                                                },
+                                                                "id": 4138,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "3149:35:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 4139,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "sig",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5569,
+                                                            "src": "3149:52:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes4_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                "typeString": "function (struct StdStorage storage pointer,bytes4) returns (struct StdStorage storage pointer)"
+                                                            }
+                                                        },
+                                                        "id": 4141,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "3149:64:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 4142,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "with_key",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5622,
+                                                    "src": "3149:86:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                    }
+                                                },
+                                                "id": 4144,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3149:90:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 4145,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "checked_write",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5729,
+                                            "src": "3149:117:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_uint256_$returns$__$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                "typeString": "function (struct StdStorage storage pointer,uint256)"
+                                            }
+                                        },
+                                        "id": 4147,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3149:123:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4148,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3149:123:6"
+                                },
+                                {
+                                    "condition": {
+                                        "id": 4149,
+                                        "name": "adjust",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 4110,
+                                        "src": "3317:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4203,
+                                    "nodeType": "IfStatement",
+                                    "src": "3314:456:6",
+                                    "trueBody": {
+                                        "id": 4202,
+                                        "nodeType": "Block",
+                                        "src": "3324:446:6",
+                                        "statements": [
+                                            {
+                                                "assignments": [null, 4151],
+                                                "declarations": [
+                                                    null,
+                                                    {
+                                                        "constant": false,
+                                                        "id": 4151,
+                                                        "mutability": "mutable",
+                                                        "name": "totSupData",
+                                                        "nameLocation": "3354:10:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 4202,
+                                                        "src": "3341:23:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "memory",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 4150,
+                                                            "name": "bytes",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "3341:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_storage_ptr",
+                                                                "typeString": "bytes"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 4159,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "30783138313630646464",
+                                                                    "id": 4156,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "3402:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    },
+                                                                    "value": "0x18160ddd"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "id": 4154,
+                                                                    "name": "abi",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": -1,
+                                                                    "src": "3379:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_magic_abi",
+                                                                        "typeString": "abi"
+                                                                    }
+                                                                },
+                                                                "id": 4155,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "memberName": "encodeWithSelector",
+                                                                "nodeType": "MemberAccess",
+                                                                "src": "3379:22:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_abiencodewithselector_pure$_t_bytes4_$returns$_t_bytes_memory_ptr_$",
+                                                                    "typeString": "function (bytes4) pure returns (bytes memory)"
+                                                                }
+                                                            },
+                                                            "id": 4157,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "3379:34:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 4152,
+                                                            "name": "token",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4104,
+                                                            "src": "3368:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        "id": 4153,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "call",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "3368:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_barecall_payable$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                            "typeString": "function (bytes memory) payable returns (bool,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4158,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "3368:46:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                        "typeString": "tuple(bool,bytes memory)"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "3338:76:6"
+                                            },
+                                            {
+                                                "assignments": [4161],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 4161,
+                                                        "mutability": "mutable",
+                                                        "name": "totSup",
+                                                        "nameLocation": "3436:6:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 4202,
+                                                        "src": "3428:14:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 4160,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "3428:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 4169,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 4164,
+                                                            "name": "totSupData",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4151,
+                                                            "src": "3456:10:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "components": [
+                                                                {
+                                                                    "id": 4166,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                                    "src": "3469:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_type$_t_uint256_$",
+                                                                        "typeString": "type(uint256)"
+                                                                    },
+                                                                    "typeName": {
+                                                                        "id": 4165,
+                                                                        "name": "uint256",
+                                                                        "nodeType": "ElementaryTypeName",
+                                                                        "src": "3469:7:6",
+                                                                        "typeDescriptions": {}
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "id": 4167,
+                                                            "isConstant": false,
+                                                            "isInlineArray": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "TupleExpression",
+                                                            "src": "3468:9:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 4162,
+                                                            "name": "abi",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -1,
+                                                            "src": "3445:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_abi",
+                                                                "typeString": "abi"
+                                                            }
+                                                        },
+                                                        "id": 4163,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "memberName": "decode",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "3445:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_abidecode_pure$__$returns$__$",
+                                                            "typeString": "function () pure"
+                                                        }
+                                                    },
+                                                    "id": 4168,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "3445:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "3428:50:6"
+                                            },
+                                            {
+                                                "condition": {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    "id": 4172,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "id": 4170,
+                                                        "name": "give",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4108,
+                                                        "src": "3495:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "<",
+                                                    "rightExpression": {
+                                                        "id": 4171,
+                                                        "name": "prevBal",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4125,
+                                                        "src": "3502:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "3495:14:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "falseBody": {
+                                                    "id": 4188,
+                                                    "nodeType": "Block",
+                                                    "src": "3576:59:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "id": 4186,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "leftHandSide": {
+                                                                    "id": 4181,
+                                                                    "name": "totSup",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 4161,
+                                                                    "src": "3594:6:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "nodeType": "Assignment",
+                                                                "operator": "+=",
+                                                                "rightHandSide": {
+                                                                    "components": [
+                                                                        {
+                                                                            "commonType": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            },
+                                                                            "id": 4184,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftExpression": {
+                                                                                "id": 4182,
+                                                                                "name": "give",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4108,
+                                                                                "src": "3605:4:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "BinaryOperation",
+                                                                            "operator": "-",
+                                                                            "rightExpression": {
+                                                                                "id": 4183,
+                                                                                "name": "prevBal",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4125,
+                                                                                "src": "3612:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "src": "3605:14:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "id": 4185,
+                                                                    "isConstant": false,
+                                                                    "isInlineArray": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "TupleExpression",
+                                                                    "src": "3604:16:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "src": "3594:26:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "id": 4187,
+                                                            "nodeType": "ExpressionStatement",
+                                                            "src": "3594:26:6"
+                                                        }
+                                                    ]
+                                                },
+                                                "id": 4189,
+                                                "nodeType": "IfStatement",
+                                                "src": "3492:143:6",
+                                                "trueBody": {
+                                                    "id": 4180,
+                                                    "nodeType": "Block",
+                                                    "src": "3511:59:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "id": 4178,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "leftHandSide": {
+                                                                    "id": 4173,
+                                                                    "name": "totSup",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 4161,
+                                                                    "src": "3529:6:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "nodeType": "Assignment",
+                                                                "operator": "-=",
+                                                                "rightHandSide": {
+                                                                    "components": [
+                                                                        {
+                                                                            "commonType": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            },
+                                                                            "id": 4176,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftExpression": {
+                                                                                "id": 4174,
+                                                                                "name": "prevBal",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4125,
+                                                                                "src": "3540:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "BinaryOperation",
+                                                                            "operator": "-",
+                                                                            "rightExpression": {
+                                                                                "id": 4175,
+                                                                                "name": "give",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4108,
+                                                                                "src": "3550:4:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "src": "3540:14:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "id": 4177,
+                                                                    "isConstant": false,
+                                                                    "isInlineArray": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "TupleExpression",
+                                                                    "src": "3539:16:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "src": "3529:26:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "id": 4179,
+                                                            "nodeType": "ExpressionStatement",
+                                                            "src": "3529:26:6"
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 4199,
+                                                            "name": "totSup",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4161,
+                                                            "src": "3752:6:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "30783138313630646464",
+                                                                    "id": 4196,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "3709:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    },
+                                                                    "value": "0x18160ddd"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 4193,
+                                                                            "name": "token",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 4104,
+                                                                            "src": "3681:5:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 4190,
+                                                                            "name": "stdstore",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 3831,
+                                                                            "src": "3648:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                                                                                "typeString": "struct StdStorage storage ref"
+                                                                            }
+                                                                        },
+                                                                        "id": 4192,
+                                                                        "isConstant": false,
+                                                                        "isLValue": true,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "target",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 5549,
+                                                                        "src": "3648:32:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                            "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                                        }
+                                                                    },
+                                                                    "id": 4194,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "3648:39:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                    }
+                                                                },
+                                                                "id": 4195,
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "memberName": "sig",
+                                                                "nodeType": "MemberAccess",
+                                                                "referencedDeclaration": 5569,
+                                                                "src": "3648:60:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes4_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                    "typeString": "function (struct StdStorage storage pointer,bytes4) returns (struct StdStorage storage pointer)"
+                                                                }
+                                                            },
+                                                            "id": 4197,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "3648:72:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        },
+                                                        "id": 4198,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "checked_write",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 5729,
+                                                        "src": "3648:103:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_uint256_$returns$__$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                            "typeString": "function (struct StdStorage storage pointer,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4200,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "3648:111:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4201,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "3648:111:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "functionSelector": "97754ae9",
+                        "id": 4205,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deal",
+                        "nameLocation": "2870:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4111,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4104,
+                                    "mutability": "mutable",
+                                    "name": "token",
+                                    "nameLocation": "2883:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2875:13:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4103,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2875:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4106,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2898:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2890:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4105,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2890:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4108,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2910:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2902:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4107,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2902:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4110,
+                                    "mutability": "mutable",
+                                    "name": "adjust",
+                                    "nameLocation": "2921:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2916:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4109,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2916:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2874:54:6"
+                        },
+                        "returnParameters": {
+                            "id": 4112,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2936:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2861:915:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4226,
+                            "nodeType": "Block",
+                            "src": "4045:221:6",
+                            "statements": [
+                                {
+                                    "assignments": [4215],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4215,
+                                            "mutability": "mutable",
+                                            "name": "bytecode",
+                                            "nameLocation": "4068:8:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4226,
+                                            "src": "4055:21:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 4214,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "4055:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4224,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 4220,
+                                                        "name": "what",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4207,
+                                                        "src": "4107:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_string_memory_ptr",
+                                                            "typeString": "string memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_string_memory_ptr",
+                                                            "typeString": "string memory"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 4218,
+                                                        "name": "vm",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 3828,
+                                                        "src": "4096:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_Vm_$6200",
+                                                            "typeString": "contract Vm"
+                                                        }
+                                                    },
+                                                    "id": 4219,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "getCode",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 6187,
+                                                    "src": "4096:10:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_external_nonpayable$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (string memory) external returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 4221,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "4096:16:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            },
+                                            {
+                                                "id": 4222,
+                                                "name": "args",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4209,
+                                                "src": "4114:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4216,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "4079:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 4217,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "encodePacked",
+                                            "nodeType": "MemberAccess",
+                                            "src": "4079:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function () pure returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 4223,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4079:40:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "4055:64:6"
+                                },
+                                {
+                                    "AST": {
+                                        "nodeType": "YulBlock",
+                                        "src": "4181:79:6",
+                                        "statements": [
+                                            {
+                                                "nodeType": "YulAssignment",
+                                                "src": "4195:55:6",
+                                                "value": {
+                                                    "arguments": [
+                                                        {
+                                                            "kind": "number",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "4210:1:6",
+                                                            "type": "",
+                                                            "value": "0"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4217:8:6"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "4227:4:6",
+                                                                    "type": "",
+                                                                    "value": "0x20"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "add",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4213:3:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4213:19:6"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4240:8:6"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "mload",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4234:5:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4234:15:6"
+                                                        }
+                                                    ],
+                                                    "functionName": {
+                                                        "name": "create",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4203:6:6"
+                                                    },
+                                                    "nodeType": "YulFunctionCall",
+                                                    "src": "4203:47:6"
+                                                },
+                                                "variableNames": [
+                                                    {
+                                                        "name": "addr",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4195:4:6"
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    },
+                                    "documentation": "@solidity memory-safe-assembly",
+                                    "evmVersion": "london",
+                                    "externalReferences": [
+                                        {
+                                            "declaration": 4212,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4195:4:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4215,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4217:8:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4215,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4240:8:6",
+                                            "valueSize": 1
+                                        }
+                                    ],
+                                    "id": 4225,
+                                    "nodeType": "InlineAssembly",
+                                    "src": "4172:88:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "29ce9dde",
+                        "id": 4227,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deployCode",
+                        "nameLocation": "3945:10:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4210,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4207,
+                                    "mutability": "mutable",
+                                    "name": "what",
+                                    "nameLocation": "3970:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4227,
+                                    "src": "3956:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4206,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3956:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4209,
+                                    "mutability": "mutable",
+                                    "name": "args",
+                                    "nameLocation": "3989:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4227,
+                                    "src": "3976:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4208,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3976:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "3955:39:6"
+                        },
+                        "returnParameters": {
+                            "id": 4213,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4212,
+                                    "mutability": "mutable",
+                                    "name": "addr",
+                                    "nameLocation": "4035:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4227,
+                                    "src": "4027:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4211,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4027:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4026:14:6"
+                        },
+                        "scope": 4935,
+                        "src": "3936:330:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4242,
+                            "nodeType": "Block",
+                            "src": "4362:197:6",
+                            "statements": [
+                                {
+                                    "assignments": [4235],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4235,
+                                            "mutability": "mutable",
+                                            "name": "bytecode",
+                                            "nameLocation": "4385:8:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4242,
+                                            "src": "4372:21:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 4234,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "4372:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4240,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 4238,
+                                                "name": "what",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4229,
+                                                "src": "4407:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4236,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "4396:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4237,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "getCode",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6187,
+                                            "src": "4396:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function (string memory) external returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 4239,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4396:16:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "4372:40:6"
+                                },
+                                {
+                                    "AST": {
+                                        "nodeType": "YulBlock",
+                                        "src": "4474:79:6",
+                                        "statements": [
+                                            {
+                                                "nodeType": "YulAssignment",
+                                                "src": "4488:55:6",
+                                                "value": {
+                                                    "arguments": [
+                                                        {
+                                                            "kind": "number",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "4503:1:6",
+                                                            "type": "",
+                                                            "value": "0"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4510:8:6"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "4520:4:6",
+                                                                    "type": "",
+                                                                    "value": "0x20"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "add",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4506:3:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4506:19:6"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4533:8:6"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "mload",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4527:5:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4527:15:6"
+                                                        }
+                                                    ],
+                                                    "functionName": {
+                                                        "name": "create",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4496:6:6"
+                                                    },
+                                                    "nodeType": "YulFunctionCall",
+                                                    "src": "4496:47:6"
+                                                },
+                                                "variableNames": [
+                                                    {
+                                                        "name": "addr",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4488:4:6"
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    },
+                                    "documentation": "@solidity memory-safe-assembly",
+                                    "evmVersion": "london",
+                                    "externalReferences": [
+                                        {
+                                            "declaration": 4232,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4488:4:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4235,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4510:8:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4235,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4533:8:6",
+                                            "valueSize": 1
+                                        }
+                                    ],
+                                    "id": 4241,
+                                    "nodeType": "InlineAssembly",
+                                    "src": "4465:88:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "9a8325a0",
+                        "id": 4243,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deployCode",
+                        "nameLocation": "4281:10:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4230,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4229,
+                                    "mutability": "mutable",
+                                    "name": "what",
+                                    "nameLocation": "4306:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4243,
+                                    "src": "4292:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4228,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4292:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4291:20:6"
+                        },
+                        "returnParameters": {
+                            "id": 4233,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4232,
+                                    "mutability": "mutable",
+                                    "name": "addr",
+                                    "nameLocation": "4352:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4243,
+                                    "src": "4344:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4231,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4344:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4343:14:6"
+                        },
+                        "scope": 4935,
+                        "src": "4272:287:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4253,
+                            "nodeType": "Block",
+                            "src": "4827:34:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4250,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "UnaryOperation",
+                                                "operator": "!",
+                                                "prefix": true,
+                                                "src": "4848:5:6",
+                                                "subExpression": {
+                                                    "id": 4249,
+                                                    "name": "data",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4245,
+                                                    "src": "4849:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 4248,
+                                            "name": "assertTrue",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                2289, 2310
+                                            ],
+                                            "referencedDeclaration": 2289,
+                                            "src": "4837:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_bool_$returns$__$",
+                                                "typeString": "function (bool)"
+                                            }
+                                        },
+                                        "id": 4251,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4837:17:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4252,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "4837:17:6"
+                                }
+                            ]
+                        },
+                        "id": 4254,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertFalse",
+                        "nameLocation": "4787:11:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4246,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4245,
+                                    "mutability": "mutable",
+                                    "name": "data",
+                                    "nameLocation": "4804:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4254,
+                                    "src": "4799:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4244,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4799:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4798:11:6"
+                        },
+                        "returnParameters": {
+                            "id": 4247,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "4827:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "4778:83:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4267,
+                            "nodeType": "Block",
+                            "src": "4935:39:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4263,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "UnaryOperation",
+                                                "operator": "!",
+                                                "prefix": true,
+                                                "src": "4956:5:6",
+                                                "subExpression": {
+                                                    "id": 4262,
+                                                    "name": "data",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4256,
+                                                    "src": "4957:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "id": 4264,
+                                                "name": "err",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4258,
+                                                "src": "4963:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            ],
+                                            "id": 4261,
+                                            "name": "assertTrue",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                2289, 2310
+                                            ],
+                                            "referencedDeclaration": 2310,
+                                            "src": "4945:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory)"
+                                            }
+                                        },
+                                        "id": 4265,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4945:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4266,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "4945:22:6"
+                                }
+                            ]
+                        },
+                        "id": 4268,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertFalse",
+                        "nameLocation": "4876:11:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4259,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4256,
+                                    "mutability": "mutable",
+                                    "name": "data",
+                                    "nameLocation": "4893:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4268,
+                                    "src": "4888:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4255,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4888:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4258,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "4913:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4268,
+                                    "src": "4899:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4257,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4899:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4887:30:6"
+                        },
+                        "returnParameters": {
+                            "id": 4260,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "4935:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "4867:107:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4303,
+                            "nodeType": "Block",
+                            "src": "5023:283:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        },
+                                        "id": 4277,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4275,
+                                            "name": "a",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4270,
+                                            "src": "5037:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "id": 4276,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4272,
+                                            "src": "5042:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "src": "5037:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4302,
+                                    "nodeType": "IfStatement",
+                                    "src": "5033:267:6",
+                                    "trueBody": {
+                                        "id": 4301,
+                                        "nodeType": "Block",
+                                        "src": "5045:255:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061203d3d2062206e6f7420736174697366696564205b626f6f6c5d",
+                                                            "id": 4279,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5084:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_8b48ec9ac4dc7123ad32509232067c63ebae61bff18d5e06bf4dea2a25240ed2",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bool]\""
+                                                            },
+                                                            "value": "Error: a == b not satisfied [bool]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_8b48ec9ac4dc7123ad32509232067c63ebae61bff18d5e06bf4dea2a25240ed2",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bool]\""
+                                                            }
+                                                        ],
+                                                        "id": 4278,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "5064:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4280,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5064:57:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4281,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5059:62:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4283,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5160:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4284,
+                                                                "name": "b",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4272,
+                                                                "src": "5174:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4286,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5187:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4287,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5174:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4285,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5178:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4282,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5140:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4288,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5140:55:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4289,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5135:60:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4291,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5234:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4292,
+                                                                "name": "a",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4270,
+                                                                "src": "5248:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4294,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5261:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4295,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5248:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4293,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5252:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4290,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5214:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4296,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5214:55:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4297,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5209:60:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4298,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "5283:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4299,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5283:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4300,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5283:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4304,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "4989:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4273,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4270,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5003:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4304,
+                                    "src": "4998:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4269,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4998:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4272,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "5011:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4304,
+                                    "src": "5006:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4271,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5006:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4997:16:6"
+                        },
+                        "returnParameters": {
+                            "id": 4274,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "5023:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "4980:326:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4342,
+                            "nodeType": "Block",
+                            "src": "5374:250:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        },
+                                        "id": 4315,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4313,
+                                            "name": "a",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4306,
+                                            "src": "5388:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "id": 4314,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4308,
+                                            "src": "5393:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "src": "5388:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4341,
+                                    "nodeType": "IfStatement",
+                                    "src": "5384:234:6",
+                                    "trueBody": {
+                                        "id": 4340,
+                                        "nodeType": "Block",
+                                        "src": "5396:222:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4317,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5432:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4318,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4310,
+                                                            "src": "5441:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4316,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5415:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4319,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5415:30:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4320,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5410:35:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4322,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5481:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4323,
+                                                                "name": "b",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4308,
+                                                                "src": "5495:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4325,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5508:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4326,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5495:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4324,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5499:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4321,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5464:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4327,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5464:52:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4328,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5459:57:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4330,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5552:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4331,
+                                                                "name": "a",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4306,
+                                                                "src": "5566:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4333,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5579:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4334,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5566:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4332,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5570:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4329,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5535:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4335,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5535:52:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4336,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5530:57:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4337,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "5601:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4338,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5601:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4339,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5601:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4343,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "5321:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4311,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4306,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5335:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4343,
+                                    "src": "5330:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4305,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5330:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4308,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "5343:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4343,
+                                    "src": "5338:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4307,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5338:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4310,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "5360:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4343,
+                                    "src": "5346:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4309,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5346:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "5329:35:6"
+                        },
+                        "returnParameters": {
+                            "id": 4312,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "5374:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "5312:312:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4376,
+                            "nodeType": "Block",
+                            "src": "5697:256:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        },
+                                        "id": 4356,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4351,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4345,
+                                                    "src": "5721:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4350,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "5711:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4352,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "5711:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4354,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4347,
+                                                    "src": "5737:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4353,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "5727:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4355,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "5727:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "src": "5711:28:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4375,
+                                    "nodeType": "IfStatement",
+                                    "src": "5707:240:6",
+                                    "trueBody": {
+                                        "id": 4374,
+                                        "nodeType": "Block",
+                                        "src": "5741:206:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061203d3d2062206e6f7420736174697366696564205b62797465735d",
+                                                            "id": 4358,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5776:37:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_9bb7b728691fe2872efdd27bd07c4a95b3586c3b7ec3afa731a7c21a76e39cfc",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bytes]\""
+                                                            },
+                                                            "value": "Error: a == b not satisfied [bytes]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_9bb7b728691fe2872efdd27bd07c4a95b3586c3b7ec3afa731a7c21a76e39cfc",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bytes]\""
+                                                            }
+                                                        ],
+                                                        "id": 4357,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "5760:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4359,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5760:54:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4360,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5755:59:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4362,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5849:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4363,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4347,
+                                                            "src": "5863:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4361,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "5833:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4364,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5833:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4365,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5828:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4367,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5900:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4368,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4345,
+                                                            "src": "5914:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4366,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "5884:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4369,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5884:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4370,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5879:37:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4371,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "5930:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4372,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5930:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4373,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5930:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4377,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "5639:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4348,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4345,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5661:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4377,
+                                    "src": "5648:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4344,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5648:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4347,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "5677:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4377,
+                                    "src": "5664:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4346,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5664:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "5647:32:6"
+                        },
+                        "returnParameters": {
+                            "id": 4349,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "5697:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "5630:323:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4413,
+                            "nodeType": "Block",
+                            "src": "6045:243:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        },
+                                        "id": 4392,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4387,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4379,
+                                                    "src": "6069:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4386,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "6059:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4388,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "6059:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4390,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4381,
+                                                    "src": "6085:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4389,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "6075:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4391,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "6075:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "src": "6059:28:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4412,
+                                    "nodeType": "IfStatement",
+                                    "src": "6055:227:6",
+                                    "trueBody": {
+                                        "id": 4411,
+                                        "nodeType": "Block",
+                                        "src": "6089:193:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4394,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6128:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4395,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4383,
+                                                            "src": "6137:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4393,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "6108:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4396,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6108:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4397,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6103:38:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4399,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6180:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4400,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4381,
+                                                            "src": "6194:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4398,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "6160:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4401,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6160:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4402,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6155:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4404,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6235:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4405,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4379,
+                                                            "src": "6249:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4403,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "6215:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4406,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6215:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4407,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6210:41:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4408,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "6265:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4409,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6265:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4410,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "6265:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4414,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "5968:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4384,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4379,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5990:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4414,
+                                    "src": "5977:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4378,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5977:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4381,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "6006:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4414,
+                                    "src": "5993:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4380,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5993:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4383,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "6023:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4414,
+                                    "src": "6009:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4382,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6009:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "5976:51:6"
+                        },
+                        "returnParameters": {
+                            "id": 4385,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "6045:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "5959:329:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4468,
+                            "nodeType": "Block",
+                            "src": "6408:404:6",
+                            "statements": [
+                                {
+                                    "assignments": [4424],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4424,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "6426:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4468,
+                                            "src": "6418:13:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4423,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "6418:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4435,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4427,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4425,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4416,
+                                                "src": "6434:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4426,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4418,
+                                                "src": "6438:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6434:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4433,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4431,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4418,
+                                                "src": "6450:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4432,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4416,
+                                                "src": "6454:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6450:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 4434,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "6434:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4430,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4428,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4416,
+                                                "src": "6442:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4429,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4418,
+                                                "src": "6446:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6442:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "6418:37:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4438,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4436,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4424,
+                                            "src": "6470:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4437,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4420,
+                                            "src": "6478:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "6470:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4467,
+                                    "nodeType": "IfStatement",
+                                    "src": "6466:340:6",
+                                    "trueBody": {
+                                        "id": 4466,
+                                        "nodeType": "Block",
+                                        "src": "6488:318:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b75696e745d",
+                                                            "id": 4440,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6523:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [uint]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            }
+                                                        ],
+                                                        "id": 4439,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "6507:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4441,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6507:53:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4442,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6502:58:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4444,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6595:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4445,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4418,
+                                                            "src": "6609:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4443,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6579:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4446,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6579:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4447,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6574:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4449,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6646:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4450,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4416,
+                                                            "src": "6660:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4448,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6630:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4451,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6630:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4452,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6625:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4454,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6697:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4455,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4420,
+                                                            "src": "6711:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4453,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6681:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4456,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6681:39:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4457,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6676:44:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4459,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6755:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4460,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4424,
+                                                            "src": "6769:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4458,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6739:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4461,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6739:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4462,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6734:41:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4463,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "6789:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4464,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6789:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4465,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "6789:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4469,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "6303:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4421,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4416,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "6338:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4469,
+                                    "src": "6330:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4415,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6330:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4418,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "6357:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4469,
+                                    "src": "6349:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4417,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6349:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4420,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "6376:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4469,
+                                    "src": "6368:16:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4419,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6368:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "6320:70:6"
+                        },
+                        "returnParameters": {
+                            "id": 4422,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "6408:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "6294:518:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4526,
+                            "nodeType": "Block",
+                            "src": "6959:400:6",
+                            "statements": [
+                                {
+                                    "assignments": [4481],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4481,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "6977:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4526,
+                                            "src": "6969:13:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4480,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "6969:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4492,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4484,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4482,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4471,
+                                                "src": "6985:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4483,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4473,
+                                                "src": "6989:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6985:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4490,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4488,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4473,
+                                                "src": "7001:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4489,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4471,
+                                                "src": "7005:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "7001:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 4491,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "6985:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4487,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4485,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4471,
+                                                "src": "6993:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4486,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4473,
+                                                "src": "6997:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6993:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "6969:37:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4495,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4493,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4481,
+                                            "src": "7021:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4494,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4475,
+                                            "src": "7029:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "7021:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4525,
+                                    "nodeType": "IfStatement",
+                                    "src": "7017:336:6",
+                                    "trueBody": {
+                                        "id": 4524,
+                                        "nodeType": "Block",
+                                        "src": "7039:314:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4497,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7078:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4498,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4477,
+                                                            "src": "7087:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4496,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "7058:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4499,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7058:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4500,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7053:38:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4502,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7130:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4503,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4473,
+                                                            "src": "7144:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4501,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7110:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4504,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7110:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4505,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7105:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4507,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7185:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4508,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4471,
+                                                            "src": "7199:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4506,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7165:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4509,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7165:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4510,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7160:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4512,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7240:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4513,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4475,
+                                                            "src": "7254:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4511,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7220:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4514,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7220:43:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4515,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7215:48:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4517,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7302:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4518,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4481,
+                                                            "src": "7316:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4516,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7282:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4519,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7282:40:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4520,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7277:45:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4521,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "7336:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4522,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7336:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4523,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "7336:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4527,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "6827:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4478,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4471,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "6862:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6854:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4470,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6854:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4473,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "6881:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6873:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4472,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6873:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4475,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "6900:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6892:16:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4474,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6892:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4477,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "6932:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6918:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4476,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6918:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "6844:97:6"
+                        },
+                        "returnParameters": {
+                            "id": 4479,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "6959:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "6818:541:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4581,
+                            "nodeType": "Block",
+                            "src": "7476:402:6",
+                            "statements": [
+                                {
+                                    "assignments": [4537],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4537,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "7493:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4581,
+                                            "src": "7486:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4536,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "7486:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4548,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4540,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4538,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4529,
+                                                "src": "7501:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4539,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4531,
+                                                "src": "7505:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "7501:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4546,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4544,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4531,
+                                                "src": "7517:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4545,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4529,
+                                                "src": "7521:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "7517:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "id": 4547,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "7501:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4543,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4541,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4529,
+                                                "src": "7509:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4542,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4531,
+                                                "src": "7513:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "7509:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "7486:36:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4551,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4549,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4537,
+                                            "src": "7537:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4550,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4533,
+                                            "src": "7545:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "7537:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4580,
+                                    "nodeType": "IfStatement",
+                                    "src": "7533:339:6",
+                                    "trueBody": {
+                                        "id": 4579,
+                                        "nodeType": "Block",
+                                        "src": "7555:317:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b696e745d",
+                                                            "id": 4553,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7590:35:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_11d61c8cdd58caffa5994831eb66eb6db7a7b4d13b2c9d187ffbe992d75f810d",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [int]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [int]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_11d61c8cdd58caffa5994831eb66eb6db7a7b4d13b2c9d187ffbe992d75f810d",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [int]\""
+                                                            }
+                                                        ],
+                                                        "id": 4552,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "7574:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4554,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7574:52:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4555,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7569:57:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4557,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7661:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4558,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4531,
+                                                            "src": "7675:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4556,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7645:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4559,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7645:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4560,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7640:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4562,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7712:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4563,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4529,
+                                                            "src": "7726:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4561,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7696:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4564,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7696:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4565,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7691:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4567,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7763:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4568,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4533,
+                                                            "src": "7777:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4566,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7747:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4569,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7747:39:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4570,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7742:44:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4572,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7821:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4573,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4537,
+                                                            "src": "7835:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4571,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7805:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4574,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7805:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4575,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7800:41:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4576,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "7855:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4577,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7855:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4578,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "7855:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4582,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "7374:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4534,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4529,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "7408:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4582,
+                                    "src": "7401:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4528,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7401:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4531,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "7426:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4582,
+                                    "src": "7419:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4530,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7419:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4533,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "7444:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4582,
+                                    "src": "7437:15:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4532,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7437:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "7391:67:6"
+                        },
+                        "returnParameters": {
+                            "id": 4535,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "7476:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "7365:513:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4639,
+                            "nodeType": "Block",
+                            "src": "8022:399:6",
+                            "statements": [
+                                {
+                                    "assignments": [4594],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4594,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "8039:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4639,
+                                            "src": "8032:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4593,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "8032:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4605,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4597,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4595,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4584,
+                                                "src": "8047:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4596,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4586,
+                                                "src": "8051:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "8047:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4603,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4601,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4586,
+                                                "src": "8063:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4602,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4584,
+                                                "src": "8067:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "8063:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "id": 4604,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "8047:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4600,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4598,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4584,
+                                                "src": "8055:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4599,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4586,
+                                                "src": "8059:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "8055:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "8032:36:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4608,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4606,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4594,
+                                            "src": "8083:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4607,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4588,
+                                            "src": "8091:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "8083:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4638,
+                                    "nodeType": "IfStatement",
+                                    "src": "8079:336:6",
+                                    "trueBody": {
+                                        "id": 4637,
+                                        "nodeType": "Block",
+                                        "src": "8101:314:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4610,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8140:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4611,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4590,
+                                                            "src": "8149:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4609,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "8120:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4612,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8120:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4613,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8115:38:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4615,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8192:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4616,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4586,
+                                                            "src": "8206:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4614,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8172:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4617,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8172:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4618,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8167:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4620,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8247:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4621,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4584,
+                                                            "src": "8261:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4619,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8227:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4622,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8227:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4623,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8222:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4625,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8302:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4626,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4588,
+                                                            "src": "8316:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4624,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8282:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4627,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8282:43:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4628,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8277:48:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4630,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8364:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4631,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4594,
+                                                            "src": "8378:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4629,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8344:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4632,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8344:40:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4633,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8339:45:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4634,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "8398:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4635,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8398:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4636,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "8398:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4640,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "7893:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4591,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4584,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "7927:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7920:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4583,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7920:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4586,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "7945:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7938:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4585,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7938:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4588,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "7963:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7956:15:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4587,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7956:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4590,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "7995:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7981:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4589,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7981:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "7910:94:6"
+                        },
+                        "returnParameters": {
+                            "id": 4592,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "8022:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "7884:537:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4711,
+                            "nodeType": "Block",
+                            "src": "8604:599:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4651,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4649,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4644,
+                                            "src": "8618:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4650,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "8623:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "8618:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4657,
+                                    "nodeType": "IfStatement",
+                                    "src": "8614:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4653,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4642,
+                                                    "src": "8642:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4654,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4644,
+                                                    "src": "8645:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "id": 4652,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2534,
+                                                "src": "8633:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_uint256_$_t_uint256_$returns$__$",
+                                                    "typeString": "function (uint256,uint256)"
+                                                }
+                                            },
+                                            "id": 4655,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "8633:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4648,
+                                        "id": 4656,
+                                        "nodeType": "Return",
+                                        "src": "8626:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4659],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4659,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "8711:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4711,
+                                            "src": "8703:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4658,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "8703:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4676,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4675,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    "id": 4672,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4662,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4660,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4642,
+                                                                        "src": "8728:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4661,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4644,
+                                                                        "src": "8732:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "8728:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4668,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4666,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4644,
+                                                                        "src": "8744:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4667,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4642,
+                                                                        "src": "8748:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "8744:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "id": 4669,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "8728:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4665,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4663,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4642,
+                                                                        "src": "8736:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4664,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4644,
+                                                                        "src": "8740:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "8736:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4670,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "8727:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4671,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "8753:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "8727:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4673,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "8726:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4674,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4644,
+                                            "src": "8761:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "8726:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "8703:59:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4679,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4677,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4659,
+                                            "src": "8777:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4678,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4646,
+                                            "src": "8792:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "8777:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4710,
+                                    "nodeType": "IfStatement",
+                                    "src": "8773:424:6",
+                                    "trueBody": {
+                                        "id": 4709,
+                                        "nodeType": "Block",
+                                        "src": "8809:388:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b75696e745d",
+                                                            "id": 4681,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8852:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [uint]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            }
+                                                        ],
+                                                        "id": 4680,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "8828:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4682,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8828:61:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4683,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8823:66:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4685,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8932:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4686,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4644,
+                                                            "src": "8948:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4684,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "8908:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4687,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8908:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4688,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8903:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4690,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8993:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4691,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4642,
+                                                            "src": "9009:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4689,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "8969:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4692,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8969:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4693,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8964:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4695,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9054:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4696,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4646,
+                                                            "src": "9070:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4697,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9087:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4694,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9030:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4698,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9030:60:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4699,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9025:65:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4701,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9133:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4702,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4659,
+                                                            "src": "9149:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4703,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9163:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4700,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9109:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4704,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9109:57:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4705,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9104:62:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4706,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "9180:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4707,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9180:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4708,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "9180:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4712,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "8436:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4647,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4642,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "8471:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4712,
+                                    "src": "8463:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4641,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "8463:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4644,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "8490:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4712,
+                                    "src": "8482:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4643,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "8482:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4646,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "8509:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4712,
+                                    "src": "8501:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4645,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "8501:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "8453:133:6"
+                        },
+                        "returnParameters": {
+                            "id": 4648,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "8604:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "8427:776:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4786,
+                            "nodeType": "Block",
+                            "src": "9413:575:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4725,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4723,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4716,
+                                            "src": "9427:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4724,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "9432:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "9427:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4731,
+                                    "nodeType": "IfStatement",
+                                    "src": "9423:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4727,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4714,
+                                                    "src": "9451:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4728,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4716,
+                                                    "src": "9454:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "id": 4726,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2534,
+                                                "src": "9442:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_uint256_$_t_uint256_$returns$__$",
+                                                    "typeString": "function (uint256,uint256)"
+                                                }
+                                            },
+                                            "id": 4729,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "9442:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4722,
+                                        "id": 4730,
+                                        "nodeType": "Return",
+                                        "src": "9435:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4733],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4733,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "9520:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4786,
+                                            "src": "9512:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4732,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "9512:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4750,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4749,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    "id": 4746,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4736,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4734,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4714,
+                                                                        "src": "9537:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4735,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4716,
+                                                                        "src": "9541:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "9537:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4742,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4740,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4716,
+                                                                        "src": "9553:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4741,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4714,
+                                                                        "src": "9557:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "9553:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "id": 4743,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "9537:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4739,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4737,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4714,
+                                                                        "src": "9545:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4738,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4716,
+                                                                        "src": "9549:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "9545:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4744,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "9536:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4745,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "9562:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "9536:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4747,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "9535:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4748,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4716,
+                                            "src": "9570:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "9535:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "9512:59:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4753,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4751,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4733,
+                                            "src": "9586:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4752,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4718,
+                                            "src": "9601:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "9586:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4785,
+                                    "nodeType": "IfStatement",
+                                    "src": "9582:400:6",
+                                    "trueBody": {
+                                        "id": 4784,
+                                        "nodeType": "Block",
+                                        "src": "9618:364:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4755,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9661:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4756,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4720,
+                                                            "src": "9670:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4754,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "9637:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4757,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9637:37:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4758,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9632:42:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4760,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9717:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4761,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4716,
+                                                            "src": "9733:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4759,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "9693:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4762,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9693:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4763,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9688:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4765,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9778:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4766,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4714,
+                                                            "src": "9794:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4764,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "9754:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4767,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9754:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4768,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9749:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4770,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9839:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4771,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4718,
+                                                            "src": "9855:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4772,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9872:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4769,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9815:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4773,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9815:60:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4774,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9810:65:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4776,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9918:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4777,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4733,
+                                                            "src": "9934:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4778,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9948:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4775,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9894:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4779,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9894:57:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4780,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9889:62:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4781,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "9965:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4782,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9965:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4783,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "9965:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4787,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "9218:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4721,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4714,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "9253:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9245:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4713,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9245:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4716,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "9272:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9264:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4715,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9264:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4718,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "9291:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9283:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4717,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9283:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4720,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "9386:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9372:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4719,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9372:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "9235:160:6"
+                        },
+                        "returnParameters": {
+                            "id": 4722,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "9413:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "9209:779:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4858,
+                            "nodeType": "Block",
+                            "src": "10168:593:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4798,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4796,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4791,
+                                            "src": "10182:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4797,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "10187:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "10182:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4804,
+                                    "nodeType": "IfStatement",
+                                    "src": "10178:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4800,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4789,
+                                                    "src": "10206:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4801,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4791,
+                                                    "src": "10209:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                ],
+                                                "id": 4799,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2479,
+                                                "src": "10197:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_int256_$_t_int256_$returns$__$",
+                                                    "typeString": "function (int256,int256)"
+                                                }
+                                            },
+                                            "id": 4802,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "10197:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4795,
+                                        "id": 4803,
+                                        "nodeType": "Return",
+                                        "src": "10190:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4806],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4806,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "10274:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4858,
+                                            "src": "10267:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4805,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "10267:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4823,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4822,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    "id": 4819,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4809,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4807,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4789,
+                                                                        "src": "10291:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4808,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4791,
+                                                                        "src": "10295:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "10291:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4815,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4813,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4791,
+                                                                        "src": "10307:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4814,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4789,
+                                                                        "src": "10311:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "10307:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "id": 4816,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "10291:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4812,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4810,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4789,
+                                                                        "src": "10299:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4811,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4791,
+                                                                        "src": "10303:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "10299:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_int256",
+                                                                    "typeString": "int256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4817,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "10290:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_int256",
+                                                            "typeString": "int256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4818,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "10316:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "10290:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4820,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "10289:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4821,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4791,
+                                            "src": "10324:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "10289:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "10267:58:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4826,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4824,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4806,
+                                            "src": "10340:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4825,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4793,
+                                            "src": "10355:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "10340:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4857,
+                                    "nodeType": "IfStatement",
+                                    "src": "10336:419:6",
+                                    "trueBody": {
+                                        "id": 4856,
+                                        "nodeType": "Block",
+                                        "src": "10372:383:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b75696e745d",
+                                                            "id": 4828,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10414:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [uint]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            }
+                                                        ],
+                                                        "id": 4827,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "10391:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4829,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10391:60:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4830,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10386:65:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4832,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10493:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4833,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4791,
+                                                            "src": "10509:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4831,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "10470:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4834,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10470:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4835,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10465:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4837,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10553:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4838,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4789,
+                                                            "src": "10569:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4836,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "10530:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4839,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10530:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4840,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10525:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4842,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10613:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4843,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4793,
+                                                            "src": "10629:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4844,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10646:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4841,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "10590:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4845,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10590:59:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4846,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10585:64:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4848,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10691:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4849,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4806,
+                                                            "src": "10707:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4850,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10721:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4847,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "10668:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4851,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10668:56:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4852,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10663:61:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4853,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "10738:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4854,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10738:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4855,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "10738:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4859,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "10003:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4794,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4789,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "10037:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4859,
+                                    "src": "10030:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4788,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10030:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4791,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "10055:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4859,
+                                    "src": "10048:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4790,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10048:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4793,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "10073:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4859,
+                                    "src": "10066:22:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4792,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10066:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "10020:130:6"
+                        },
+                        "returnParameters": {
+                            "id": 4795,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "10168:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "9994:767:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4933,
+                            "nodeType": "Block",
+                            "src": "10968:569:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4872,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4870,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4863,
+                                            "src": "10982:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4871,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "10987:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "10982:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4878,
+                                    "nodeType": "IfStatement",
+                                    "src": "10978:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4874,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4861,
+                                                    "src": "11006:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4875,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4863,
+                                                    "src": "11009:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                ],
+                                                "id": 4873,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2479,
+                                                "src": "10997:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_int256_$_t_int256_$returns$__$",
+                                                    "typeString": "function (int256,int256)"
+                                                }
+                                            },
+                                            "id": 4876,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "10997:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4869,
+                                        "id": 4877,
+                                        "nodeType": "Return",
+                                        "src": "10990:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4880],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4880,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "11074:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4933,
+                                            "src": "11067:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4879,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "11067:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4897,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4896,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    "id": 4893,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4883,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4881,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4861,
+                                                                        "src": "11091:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4882,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4863,
+                                                                        "src": "11095:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "11091:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4889,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4887,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4863,
+                                                                        "src": "11107:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4888,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4861,
+                                                                        "src": "11111:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "11107:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "id": 4890,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "11091:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4886,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4884,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4861,
+                                                                        "src": "11099:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4885,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4863,
+                                                                        "src": "11103:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "11099:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_int256",
+                                                                    "typeString": "int256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4891,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "11090:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_int256",
+                                                            "typeString": "int256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4892,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "11116:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "11090:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4894,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "11089:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4895,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4863,
+                                            "src": "11124:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "11089:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "11067:58:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4900,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4898,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4880,
+                                            "src": "11140:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4899,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4865,
+                                            "src": "11155:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "11140:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4932,
+                                    "nodeType": "IfStatement",
+                                    "src": "11136:395:6",
+                                    "trueBody": {
+                                        "id": 4931,
+                                        "nodeType": "Block",
+                                        "src": "11172:359:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4902,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11214:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4903,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4867,
+                                                            "src": "11223:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4901,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "11191:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4904,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11191:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4905,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11186:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4907,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11269:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4908,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4863,
+                                                            "src": "11285:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4906,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "11246:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4909,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11246:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4910,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11241:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4912,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11329:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4913,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4861,
+                                                            "src": "11345:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4911,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "11306:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4914,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11306:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4915,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11301:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4917,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11389:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4918,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4865,
+                                                            "src": "11405:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4919,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11422:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4916,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "11366:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4920,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11366:59:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4921,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11361:64:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4923,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11467:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4924,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4880,
+                                                            "src": "11483:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4925,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11497:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4922,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "11444:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4926,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11444:56:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4927,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11439:61:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4928,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "11514:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4929,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11514:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4930,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "11514:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4934,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "10776:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4868,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4861,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "10810:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10803:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4860,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10803:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4863,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "10828:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10821:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4862,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10821:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4865,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "10846:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10839:22:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4864,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10839:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4867,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "10941:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10927:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4866,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10927:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "10793:157:6"
+                        },
+                        "returnParameters": {
+                            "id": 4869,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "10968:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "10767:770:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    }
+                ],
+                "scope": 5991,
+                "src": "226:11313:6",
+                "usedErrors": []
+            },
+            {
+                "abstract": false,
+                "baseContracts": [],
+                "canonicalName": "stdError",
+                "contractDependencies": [],
+                "contractKind": "library",
+                "fullyImplemented": true,
+                "id": 5005,
+                "linearizedBaseContracts": [5005],
+                "name": "stdError",
+                "nameLocation": "11748:8:6",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "constant": true,
+                        "functionSelector": "10332977",
+                        "id": 4942,
+                        "mutability": "constant",
+                        "name": "assertionError",
+                        "nameLocation": "11785:14:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "11763:86:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4936,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "11763:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4939,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11826:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783031",
+                                    "id": 4940,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11844:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_1_by_1",
+                                        "typeString": "int_const 1"
+                                    },
+                                    "value": "0x01"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_1_by_1",
+                                        "typeString": "int_const 1"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4937,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "11802:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4938,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "11802:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4941,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "11802:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "8995290f",
+                        "id": 4949,
+                        "mutability": "constant",
+                        "name": "arithmeticError",
+                        "nameLocation": "11877:15:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "11855:87:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4943,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "11855:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4946,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11919:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783131",
+                                    "id": 4947,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11937:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_17_by_1",
+                                        "typeString": "int_const 17"
+                                    },
+                                    "value": "0x11"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_17_by_1",
+                                        "typeString": "int_const 17"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4944,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "11895:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4945,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "11895:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4948,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "11895:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "fa784a44",
+                        "id": 4956,
+                        "mutability": "constant",
+                        "name": "divisionError",
+                        "nameLocation": "11970:13:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "11948:85:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4950,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "11948:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4953,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12010:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783132",
+                                    "id": 4954,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12028:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_18_by_1",
+                                        "typeString": "int_const 18"
+                                    },
+                                    "value": "0x12"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_18_by_1",
+                                        "typeString": "int_const 18"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4951,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "11986:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4952,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "11986:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4955,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "11986:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "1de45560",
+                        "id": 4963,
+                        "mutability": "constant",
+                        "name": "enumConversionError",
+                        "nameLocation": "12061:19:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12039:91:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4957,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12039:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4960,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12107:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783231",
+                                    "id": 4961,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12125:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_33_by_1",
+                                        "typeString": "int_const 33"
+                                    },
+                                    "value": "0x21"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_33_by_1",
+                                        "typeString": "int_const 33"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4958,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12083:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4959,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12083:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4962,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12083:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "d160e4de",
+                        "id": 4970,
+                        "mutability": "constant",
+                        "name": "encodeStorageError",
+                        "nameLocation": "12158:18:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12136:90:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4964,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12136:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4967,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12203:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783232",
+                                    "id": 4968,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12221:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_34_by_1",
+                                        "typeString": "int_const 34"
+                                    },
+                                    "value": "0x22"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_34_by_1",
+                                        "typeString": "int_const 34"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4965,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12179:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4966,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12179:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4969,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12179:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "b22dc54d",
+                        "id": 4977,
+                        "mutability": "constant",
+                        "name": "popError",
+                        "nameLocation": "12254:8:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12232:80:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4971,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12232:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4974,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12289:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783331",
+                                    "id": 4975,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12307:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_49_by_1",
+                                        "typeString": "int_const 49"
+                                    },
+                                    "value": "0x31"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_49_by_1",
+                                        "typeString": "int_const 49"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4972,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12265:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4973,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12265:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4976,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12265:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "05ee8612",
+                        "id": 4984,
+                        "mutability": "constant",
+                        "name": "indexOOBError",
+                        "nameLocation": "12340:13:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12318:85:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4978,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12318:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4981,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12380:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783332",
+                                    "id": 4982,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12398:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_50_by_1",
+                                        "typeString": "int_const 50"
+                                    },
+                                    "value": "0x32"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_50_by_1",
+                                        "typeString": "int_const 50"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4979,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12356:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4980,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12356:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4983,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12356:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "986c5f68",
+                        "id": 4991,
+                        "mutability": "constant",
+                        "name": "memOverflowError",
+                        "nameLocation": "12431:16:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12409:88:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4985,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12409:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4988,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12474:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783431",
+                                    "id": 4989,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12492:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_65_by_1",
+                                        "typeString": "int_const 65"
+                                    },
+                                    "value": "0x41"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_65_by_1",
+                                        "typeString": "int_const 65"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4986,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12450:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4987,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12450:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4990,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12450:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "b67689da",
+                        "id": 4998,
+                        "mutability": "constant",
+                        "name": "zeroVarError",
+                        "nameLocation": "12525:12:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12503:84:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4992,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12503:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4995,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12564:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783531",
+                                    "id": 4996,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12582:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_81_by_1",
+                                        "typeString": "int_const 81"
+                                    },
+                                    "value": "0x51"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_81_by_1",
+                                        "typeString": "int_const 81"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4993,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12540:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4994,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12540:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4997,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12540:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "ac3d92c6",
+                        "id": 5004,
+                        "mutability": "constant",
+                        "name": "lowLevelError",
+                        "nameLocation": "12690:13:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12668:47:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4999,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12668:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "",
+                                    "id": 5002,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12712:2:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+                                        "typeString": "literal_string \"\""
+                                    },
+                                    "value": ""
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+                                        "typeString": "literal_string \"\""
+                                    }
+                                ],
+                                "id": 5001,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "nodeType": "ElementaryTypeNameExpression",
+                                "src": "12706:5:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_bytes_storage_ptr_$",
+                                    "typeString": "type(bytes storage pointer)"
+                                },
+                                "typeName": {
+                                    "id": 5000,
+                                    "name": "bytes",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "12706:5:6",
+                                    "typeDescriptions": {}
+                                }
+                            },
+                            "id": 5003,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12706:9:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    }
+                ],
+                "scope": 5991,
+                "src": "11740:986:6",
+                "usedErrors": []
+            },
+            {
+                "canonicalName": "StdStorage",
+                "id": 5033,
+                "members": [
+                    {
+                        "constant": false,
+                        "id": 5013,
+                        "mutability": "mutable",
+                        "name": "slots",
+                        "nameLocation": "13019:5:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "12951:73:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                            "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                        },
+                        "typeName": {
+                            "id": 5012,
+                            "keyType": {
+                                "id": 5006,
+                                "name": "address",
+                                "nodeType": "ElementaryTypeName",
+                                "src": "12960:7:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_address",
+                                    "typeString": "address"
+                                }
+                            },
+                            "nodeType": "Mapping",
+                            "src": "12951:67:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                            },
+                            "valueType": {
+                                "id": 5011,
+                                "keyType": {
+                                    "id": 5007,
+                                    "name": "bytes4",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "12979:6:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    }
+                                },
+                                "nodeType": "Mapping",
+                                "src": "12971:46:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                    "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                },
+                                "valueType": {
+                                    "id": 5010,
+                                    "keyType": {
+                                        "id": 5008,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "12997:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "Mapping",
+                                    "src": "12989:27:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                        "typeString": "mapping(bytes32 => uint256)"
+                                    },
+                                    "valueType": {
+                                        "id": 5009,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13008:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5021,
+                        "mutability": "mutable",
+                        "name": "finds",
+                        "nameLocation": "13096:5:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13030:71:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                            "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                        },
+                        "typeName": {
+                            "id": 5020,
+                            "keyType": {
+                                "id": 5014,
+                                "name": "address",
+                                "nodeType": "ElementaryTypeName",
+                                "src": "13039:7:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_address",
+                                    "typeString": "address"
+                                }
+                            },
+                            "nodeType": "Mapping",
+                            "src": "13030:65:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                            },
+                            "valueType": {
+                                "id": 5019,
+                                "keyType": {
+                                    "id": 5015,
+                                    "name": "bytes4",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "13058:6:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    }
+                                },
+                                "nodeType": "Mapping",
+                                "src": "13050:44:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                    "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                },
+                                "valueType": {
+                                    "id": 5018,
+                                    "keyType": {
+                                        "id": 5016,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13077:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "Mapping",
+                                    "src": "13069:24:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                        "typeString": "mapping(bytes32 => bool)"
+                                    },
+                                    "valueType": {
+                                        "id": 5017,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13088:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5024,
+                        "mutability": "mutable",
+                        "name": "_keys",
+                        "nameLocation": "13118:5:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13108:15:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                            "typeString": "bytes32[]"
+                        },
+                        "typeName": {
+                            "baseType": {
+                                "id": 5022,
+                                "name": "bytes32",
+                                "nodeType": "ElementaryTypeName",
+                                "src": "13108:7:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_bytes32",
+                                    "typeString": "bytes32"
+                                }
+                            },
+                            "id": 5023,
+                            "nodeType": "ArrayTypeName",
+                            "src": "13108:9:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                "typeString": "bytes32[]"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5026,
+                        "mutability": "mutable",
+                        "name": "_sig",
+                        "nameLocation": "13136:4:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13129:11:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes4",
+                            "typeString": "bytes4"
+                        },
+                        "typeName": {
+                            "id": 5025,
+                            "name": "bytes4",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13129:6:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes4",
+                                "typeString": "bytes4"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5028,
+                        "mutability": "mutable",
+                        "name": "_depth",
+                        "nameLocation": "13154:6:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13146:14:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                        },
+                        "typeName": {
+                            "id": 5027,
+                            "name": "uint256",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13146:7:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_uint256",
+                                "typeString": "uint256"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5030,
+                        "mutability": "mutable",
+                        "name": "_target",
+                        "nameLocation": "13174:7:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13166:15:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_address",
+                            "typeString": "address"
+                        },
+                        "typeName": {
+                            "id": 5029,
+                            "name": "address",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13166:7:6",
+                            "stateMutability": "nonpayable",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_address",
+                                "typeString": "address"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5032,
+                        "mutability": "mutable",
+                        "name": "_set",
+                        "nameLocation": "13195:4:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13187:12:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes32",
+                            "typeString": "bytes32"
+                        },
+                        "typeName": {
+                            "id": 5031,
+                            "name": "bytes32",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13187:7:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes32",
+                                "typeString": "bytes32"
+                            }
+                        },
+                        "visibility": "internal"
+                    }
+                ],
+                "name": "StdStorage",
+                "nameLocation": "12934:10:6",
+                "nodeType": "StructDefinition",
+                "scope": 5991,
+                "src": "12927:275:6",
+                "visibility": "public"
+            },
+            {
+                "abstract": false,
+                "baseContracts": [],
+                "canonicalName": "stdStorage",
+                "contractDependencies": [],
+                "contractKind": "library",
+                "fullyImplemented": true,
+                "id": 5990,
+                "linearizedBaseContracts": [5990],
+                "name": "stdStorage",
+                "nameLocation": "13212:10:6",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "anonymous": false,
+                        "id": 5043,
+                        "name": "SlotFound",
+                        "nameLocation": "13235:9:6",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 5042,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5035,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "13253:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13245:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5034,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13245:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5037,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "fsig",
+                                    "nameLocation": "13265:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13258:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    },
+                                    "typeName": {
+                                        "id": 5036,
+                                        "name": "bytes4",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13258:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5039,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "keysHash",
+                                    "nameLocation": "13279:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13271:16:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5038,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13271:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5041,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "slot",
+                                    "nameLocation": "13294:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13289:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5040,
+                                        "name": "uint",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13289:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13244:55:6"
+                        },
+                        "src": "13229:71:6"
+                    },
+                    {
+                        "anonymous": false,
+                        "id": 5049,
+                        "name": "WARNING_UninitedSlot",
+                        "nameLocation": "13311:20:6",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 5048,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5045,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "13340:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5049,
+                                    "src": "13332:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5044,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13332:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5047,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "slot",
+                                    "nameLocation": "13350:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5049,
+                                    "src": "13345:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5046,
+                                        "name": "uint",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13345:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13331:24:6"
+                        },
+                        "src": "13305:51:6"
+                    },
+                    {
+                        "constant": true,
+                        "id": 5066,
+                        "mutability": "constant",
+                        "name": "vm_std_store",
+                        "nameLocation": "13382:12:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5990,
+                        "src": "13362:94:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_Vm_$6200",
+                            "typeString": "contract Vm"
+                        },
+                        "typeName": {
+                            "id": 5051,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 5050,
+                                "name": "Vm",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6200,
+                                "src": "13362:2:6"
+                            },
+                            "referencedDeclaration": 6200,
+                            "src": "13362:2:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "arguments": [
+                                        {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "6865766d20636865617420636f6465",
+                                                                    "id": 5060,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "string",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "13434:17:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_stringliteral_885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d",
+                                                                        "typeString": "literal_string \"hevm cheat code\""
+                                                                    },
+                                                                    "value": "hevm cheat code"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_stringliteral_885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d",
+                                                                        "typeString": "literal_string \"hevm cheat code\""
+                                                                    }
+                                                                ],
+                                                                "id": 5059,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "13424:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5061,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "13424:28:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        ],
+                                                        "id": 5058,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "13416:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_uint256_$",
+                                                            "typeString": "type(uint256)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 5057,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "13416:7:6",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    },
+                                                    "id": 5062,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "typeConversion",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "13416:37:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "id": 5056,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "nodeType": "ElementaryTypeNameExpression",
+                                                "src": "13408:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_uint160_$",
+                                                    "typeString": "type(uint160)"
+                                                },
+                                                "typeName": {
+                                                    "id": 5055,
+                                                    "name": "uint160",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "13408:7:6",
+                                                    "typeDescriptions": {}
+                                                }
+                                            },
+                                            "id": 5063,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "13408:46:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint160",
+                                                "typeString": "uint160"
+                                            }
+                                        }
+                                    ],
+                                    "expression": {
+                                        "argumentTypes": [
+                                            {
+                                                "typeIdentifier": "t_uint160",
+                                                "typeString": "uint160"
+                                            }
+                                        ],
+                                        "id": 5054,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": true,
+                                        "lValueRequested": false,
+                                        "nodeType": "ElementaryTypeNameExpression",
+                                        "src": "13400:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_type$_t_address_$",
+                                            "typeString": "type(address)"
+                                        },
+                                        "typeName": {
+                                            "id": 5053,
+                                            "name": "address",
+                                            "nodeType": "ElementaryTypeName",
+                                            "src": "13400:7:6",
+                                            "typeDescriptions": {}
+                                        }
+                                    },
+                                    "id": 5064,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "typeConversion",
+                                    "lValueRequested": false,
+                                    "names": [],
+                                    "nodeType": "FunctionCall",
+                                    "src": "13400:55:6",
+                                    "tryCall": false,
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                ],
+                                "id": 5052,
+                                "name": "Vm",
+                                "nodeType": "Identifier",
+                                "overloadedDeclarations": [],
+                                "referencedDeclaration": 6200,
+                                "src": "13397:2:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_contract$_Vm_$6200_$",
+                                    "typeString": "type(contract Vm)"
+                                }
+                            },
+                            "id": 5065,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "13397:59:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "visibility": "private"
+                    },
+                    {
+                        "body": {
+                            "id": 5083,
+                            "nodeType": "Block",
+                            "src": "13572:56:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "id": 5078,
+                                                                "name": "sigStr",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5068,
+                                                                "src": "13612:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                                    "typeString": "string memory"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                                    "typeString": "string memory"
+                                                                }
+                                                            ],
+                                                            "id": 5077,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "13606:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_bytes_storage_ptr_$",
+                                                                "typeString": "type(bytes storage pointer)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5076,
+                                                                "name": "bytes",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "13606:5:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5079,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "13606:13:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "id": 5075,
+                                                    "name": "keccak256",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": -8,
+                                                    "src": "13596:9:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                        "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                    }
+                                                },
+                                                "id": 5080,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "13596:24:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5074,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "nodeType": "ElementaryTypeNameExpression",
+                                            "src": "13589:6:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_type$_t_bytes4_$",
+                                                "typeString": "type(bytes4)"
+                                            },
+                                            "typeName": {
+                                                "id": 5073,
+                                                "name": "bytes4",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "13589:6:6",
+                                                "typeDescriptions": {}
+                                            }
+                                        },
+                                        "id": 5081,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "typeConversion",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "13589:32:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5072,
+                                    "id": 5082,
+                                    "nodeType": "Return",
+                                    "src": "13582:39:6"
+                                }
+                            ]
+                        },
+                        "id": 5084,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "sigs",
+                        "nameLocation": "13472:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5069,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5068,
+                                    "mutability": "mutable",
+                                    "name": "sigStr",
+                                    "nameLocation": "13500:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5084,
+                                    "src": "13486:20:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 5067,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13486:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13476:36:6"
+                        },
+                        "returnParameters": {
+                            "id": 5072,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5071,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5084,
+                                    "src": "13560:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    },
+                                    "typeName": {
+                                        "id": 5070,
+                                        "name": "bytes4",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13560:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13559:8:6"
+                        },
+                        "scope": 5990,
+                        "src": "13463:165:6",
+                        "stateMutability": "pure",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5528,
+                            "nodeType": "Block",
+                            "src": "14242:3014:6",
+                            "statements": [
+                                {
+                                    "assignments": [5094],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5094,
+                                            "mutability": "mutable",
+                                            "name": "who",
+                                            "nameLocation": "14260:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14252:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            },
+                                            "typeName": {
+                                                "id": 5093,
+                                                "name": "address",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14252:7:6",
+                                                "stateMutability": "nonpayable",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5097,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5095,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14266:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5096,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_target",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5030,
+                                        "src": "14266:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14252:26:6"
+                                },
+                                {
+                                    "assignments": [5099],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5099,
+                                            "mutability": "mutable",
+                                            "name": "fsig",
+                                            "nameLocation": "14295:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14288:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            },
+                                            "typeName": {
+                                                "id": 5098,
+                                                "name": "bytes4",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14288:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5102,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5100,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14302:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5101,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_sig",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5026,
+                                        "src": "14302:9:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14288:23:6"
+                                },
+                                {
+                                    "assignments": [5104],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5104,
+                                            "mutability": "mutable",
+                                            "name": "field_depth",
+                                            "nameLocation": "14329:11:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14321:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 5103,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14321:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5107,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5105,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14343:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5106,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_depth",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5028,
+                                        "src": "14343:11:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14321:33:6"
+                                },
+                                {
+                                    "assignments": [5112],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5112,
+                                            "mutability": "mutable",
+                                            "name": "ins",
+                                            "nameLocation": "14381:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14364:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                "typeString": "bytes32[]"
+                                            },
+                                            "typeName": {
+                                                "baseType": {
+                                                    "id": 5110,
+                                                    "name": "bytes32",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "14364:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5111,
+                                                "nodeType": "ArrayTypeName",
+                                                "src": "14364:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                                    "typeString": "bytes32[]"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5115,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5113,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14387:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5114,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_keys",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5024,
+                                        "src": "14387:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                            "typeString": "bytes32[] storage ref"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14364:33:6"
+                                },
+                                {
+                                    "condition": {
+                                        "baseExpression": {
+                                            "baseExpression": {
+                                                "baseExpression": {
+                                                    "expression": {
+                                                        "id": 5116,
+                                                        "name": "self",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5088,
+                                                        "src": "14448:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 5117,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "finds",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5021,
+                                                    "src": "14448:10:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                    }
+                                                },
+                                                "id": 5119,
+                                                "indexExpression": {
+                                                    "id": 5118,
+                                                    "name": "who",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5094,
+                                                    "src": "14459:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "14448:15:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                }
+                                            },
+                                            "id": 5121,
+                                            "indexExpression": {
+                                                "id": 5120,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5099,
+                                                "src": "14464:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "IndexAccess",
+                                            "src": "14448:21:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                "typeString": "mapping(bytes32 => bool)"
+                                            }
+                                        },
+                                        "id": 5129,
+                                        "indexExpression": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5125,
+                                                            "name": "ins",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5112,
+                                                            "src": "14497:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "id": 5126,
+                                                            "name": "field_depth",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5104,
+                                                            "src": "14502:11:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 5123,
+                                                            "name": "abi",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -1,
+                                                            "src": "14480:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_abi",
+                                                                "typeString": "abi"
+                                                            }
+                                                        },
+                                                        "id": 5124,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "memberName": "encodePacked",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "14480:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                            "typeString": "function () pure returns (bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 5127,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "14480:34:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 5122,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "14470:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 5128,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "14470:45:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "IndexAccess",
+                                        "src": "14448:68:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5146,
+                                    "nodeType": "IfStatement",
+                                    "src": "14444:174:6",
+                                    "trueBody": {
+                                        "id": 5145,
+                                        "nodeType": "Block",
+                                        "src": "14518:100:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "baseExpression": {
+                                                        "baseExpression": {
+                                                            "baseExpression": {
+                                                                "expression": {
+                                                                    "id": 5130,
+                                                                    "name": "self",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5088,
+                                                                    "src": "14539:4:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                    }
+                                                                },
+                                                                "id": 5131,
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "memberName": "slots",
+                                                                "nodeType": "MemberAccess",
+                                                                "referencedDeclaration": 5013,
+                                                                "src": "14539:10:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                    "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                                }
+                                                            },
+                                                            "id": 5133,
+                                                            "indexExpression": {
+                                                                "id": 5132,
+                                                                "name": "who",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5094,
+                                                                "src": "14550:3:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_address",
+                                                                    "typeString": "address"
+                                                                }
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "14539:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                                "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                            }
+                                                        },
+                                                        "id": 5135,
+                                                        "indexExpression": {
+                                                            "id": 5134,
+                                                            "name": "fsig",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5099,
+                                                            "src": "14555:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes4",
+                                                                "typeString": "bytes4"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "14539:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                            "typeString": "mapping(bytes32 => uint256)"
+                                                        }
+                                                    },
+                                                    "id": 5143,
+                                                    "indexExpression": {
+                                                        "arguments": [
+                                                            {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5139,
+                                                                        "name": "ins",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5112,
+                                                                        "src": "14588:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                            "typeString": "bytes32[] memory"
+                                                                        }
+                                                                    },
+                                                                    {
+                                                                        "id": 5140,
+                                                                        "name": "field_depth",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5104,
+                                                                        "src": "14593:11:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                            "typeString": "bytes32[] memory"
+                                                                        },
+                                                                        {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "id": 5137,
+                                                                        "name": "abi",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": -1,
+                                                                        "src": "14571:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_magic_abi",
+                                                                            "typeString": "abi"
+                                                                        }
+                                                                    },
+                                                                    "id": 5138,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "encodePacked",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "src": "14571:16:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                    }
+                                                                },
+                                                                "id": 5141,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "14571:34:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                    "typeString": "bytes memory"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                    "typeString": "bytes memory"
+                                                                }
+                                                            ],
+                                                            "id": 5136,
+                                                            "name": "keccak256",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -8,
+                                                            "src": "14561:9:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                            }
+                                                        },
+                                                        "id": 5142,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "14561:45:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "14539:68:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "functionReturnParameters": 5092,
+                                                "id": 5144,
+                                                "nodeType": "Return",
+                                                "src": "14532:75:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "assignments": [5148],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5148,
+                                            "mutability": "mutable",
+                                            "name": "cald",
+                                            "nameLocation": "14640:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14627:17:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 5147,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14627:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5156,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 5151,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5099,
+                                                "src": "14664:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5153,
+                                                        "name": "ins",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5112,
+                                                        "src": "14678:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    ],
+                                                    "id": 5152,
+                                                    "name": "flatten",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5989,
+                                                    "src": "14670:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_pure$_t_array$_t_bytes32_$dyn_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes32[] memory) pure returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5154,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "14670:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5149,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "14647:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 5150,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "encodePacked",
+                                            "nodeType": "MemberAccess",
+                                            "src": "14647:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function () pure returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 5155,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "14647:36:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14627:56:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [],
+                                        "expression": {
+                                            "argumentTypes": [],
+                                            "expression": {
+                                                "id": 5157,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "14693:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5159,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "record",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6139,
+                                            "src": "14693:19:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$__$returns$__$",
+                                                "typeString": "function () external"
+                                            }
+                                        },
+                                        "id": 5160,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "14693:21:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5161,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "14693:21:6"
+                                },
+                                {
+                                    "assignments": [5163],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5163,
+                                            "mutability": "mutable",
+                                            "name": "fdat",
+                                            "nameLocation": "14732:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14724:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5162,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14724:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5164,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14724:12:6"
+                                },
+                                {
+                                    "id": 5181,
+                                    "nodeType": "Block",
+                                    "src": "14746:126:6",
+                                    "statements": [
+                                        {
+                                            "assignments": [null, 5166],
+                                            "declarations": [
+                                                null,
+                                                {
+                                                    "constant": false,
+                                                    "id": 5166,
+                                                    "mutability": "mutable",
+                                                    "name": "rdat",
+                                                    "nameLocation": "14776:4:6",
+                                                    "nodeType": "VariableDeclaration",
+                                                    "scope": 5181,
+                                                    "src": "14763:17:6",
+                                                    "stateVariable": false,
+                                                    "storageLocation": "memory",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5165,
+                                                        "name": "bytes",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "14763:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                                            "typeString": "bytes"
+                                                        }
+                                                    },
+                                                    "visibility": "internal"
+                                                }
+                                            ],
+                                            "id": 5171,
+                                            "initialValue": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5169,
+                                                        "name": "cald",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5148,
+                                                        "src": "14799:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 5167,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5094,
+                                                        "src": "14784:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    },
+                                                    "id": 5168,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "staticcall",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "14784:14:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes memory) view returns (bool,bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5170,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "14784:20:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                    "typeString": "tuple(bool,bytes memory)"
+                                                }
+                                            },
+                                            "nodeType": "VariableDeclarationStatement",
+                                            "src": "14760:44:6"
+                                        },
+                                        {
+                                            "expression": {
+                                                "id": 5179,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftHandSide": {
+                                                    "id": 5172,
+                                                    "name": "fdat",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5163,
+                                                    "src": "14818:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "Assignment",
+                                                "operator": "=",
+                                                "rightHandSide": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5174,
+                                                            "name": "rdat",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5166,
+                                                            "src": "14840:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "commonType": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            "id": 5177,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "leftExpression": {
+                                                                "hexValue": "3332",
+                                                                "id": 5175,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "14846:2:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_32_by_1",
+                                                                    "typeString": "int_const 32"
+                                                                },
+                                                                "value": "32"
+                                                            },
+                                                            "nodeType": "BinaryOperation",
+                                                            "operator": "*",
+                                                            "rightExpression": {
+                                                                "id": 5176,
+                                                                "name": "field_depth",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5104,
+                                                                "src": "14849:11:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "src": "14846:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 5173,
+                                                        "name": "bytesToBytes32",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5948,
+                                                        "src": "14825:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_pure$_t_bytes_memory_ptr_$_t_uint256_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory,uint256) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5178,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "14825:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "src": "14818:43:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "id": 5180,
+                                            "nodeType": "ExpressionStatement",
+                                            "src": "14818:43:6"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "assignments": [5186, null],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5186,
+                                            "mutability": "mutable",
+                                            "name": "reads",
+                                            "nameLocation": "14900:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14883:22:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                "typeString": "bytes32[]"
+                                            },
+                                            "typeName": {
+                                                "baseType": {
+                                                    "id": 5184,
+                                                    "name": "bytes32",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "14883:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5185,
+                                                "nodeType": "ArrayTypeName",
+                                                "src": "14883:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                                    "typeString": "bytes32[]"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        },
+                                        null
+                                    ],
+                                    "id": 5194,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5191,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5094,
+                                                        "src": "14941:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 5190,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "14933:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5189,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "14933:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5192,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "14933:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5187,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "14911:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5188,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "accesses",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6150,
+                                            "src": "14911:21:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$_t_array$_t_bytes32_$dyn_memory_ptr_$_t_array$_t_bytes32_$dyn_memory_ptr_$",
+                                                "typeString": "function (address) external returns (bytes32[] memory,bytes32[] memory)"
+                                            }
+                                        },
+                                        "id": 5193,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "14911:35:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$_t_array$_t_bytes32_$dyn_memory_ptr_$_t_array$_t_bytes32_$dyn_memory_ptr_$",
+                                            "typeString": "tuple(bytes32[] memory,bytes32[] memory)"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14882:64:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 5198,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "expression": {
+                                                "id": 5195,
+                                                "name": "reads",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5186,
+                                                "src": "14960:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                    "typeString": "bytes32[] memory"
+                                                }
+                                            },
+                                            "id": 5196,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "length",
+                                            "nodeType": "MemberAccess",
+                                            "src": "14960:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "31",
+                                            "id": 5197,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "14976:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_1_by_1",
+                                                "typeString": "int_const 1"
+                                            },
+                                            "value": "1"
+                                        },
+                                        "src": "14960:17:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "falseBody": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 5300,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "expression": {
+                                                    "id": 5297,
+                                                    "name": "reads",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5186,
+                                                    "src": "15638:5:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                        "typeString": "bytes32[] memory"
+                                                    }
+                                                },
+                                                "id": 5298,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "length",
+                                                "nodeType": "MemberAccess",
+                                                "src": "15638:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "hexValue": "31",
+                                                "id": 5299,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "15653:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1_by_1",
+                                                    "typeString": "int_const 1"
+                                                },
+                                                "value": "1"
+                                            },
+                                            "src": "15638:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseBody": {
+                                            "id": 5476,
+                                            "nodeType": "Block",
+                                            "src": "16876:77:6",
+                                            "statements": [
+                                                {
+                                                    "expression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 5472,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "bool",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "16898:5:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            {
+                                                                "hexValue": "4e6f2073746f726167652075736520646574656374656420666f7220746172676574",
+                                                                "id": 5473,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "16905:36:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_2d47527d82ff490318d5b489ec83c9a0ae26d9e8e2e75850ef5c9e43da453070",
+                                                                    "typeString": "literal_string \"No storage use detected for target\""
+                                                                },
+                                                                "value": "No storage use detected for target"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                },
+                                                                {
+                                                                    "typeIdentifier": "t_stringliteral_2d47527d82ff490318d5b489ec83c9a0ae26d9e8e2e75850ef5c9e43da453070",
+                                                                    "typeString": "literal_string \"No storage use detected for target\""
+                                                                }
+                                                            ],
+                                                            "id": 5471,
+                                                            "name": "require",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [
+                                                                -18, -18
+                                                            ],
+                                                            "referencedDeclaration": -18,
+                                                            "src": "16890:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                                "typeString": "function (bool,string memory) pure"
+                                                            }
+                                                        },
+                                                        "id": 5474,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "16890:52:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_tuple$__$",
+                                                            "typeString": "tuple()"
+                                                        }
+                                                    },
+                                                    "id": 5475,
+                                                    "nodeType": "ExpressionStatement",
+                                                    "src": "16890:52:6"
+                                                }
+                                            ]
+                                        },
+                                        "id": 5477,
+                                        "nodeType": "IfStatement",
+                                        "src": "15634:1319:6",
+                                        "trueBody": {
+                                            "id": 5470,
+                                            "nodeType": "Block",
+                                            "src": "15656:1214:6",
+                                            "statements": [
+                                                {
+                                                    "body": {
+                                                        "id": 5468,
+                                                        "nodeType": "Block",
+                                                        "src": "15713:1147:6",
+                                                        "statements": [
+                                                            {
+                                                                "assignments": [
+                                                                    5313
+                                                                ],
+                                                                "declarations": [
+                                                                    {
+                                                                        "constant": false,
+                                                                        "id": 5313,
+                                                                        "mutability": "mutable",
+                                                                        "name": "prev",
+                                                                        "nameLocation": "15739:4:6",
+                                                                        "nodeType": "VariableDeclaration",
+                                                                        "scope": 5468,
+                                                                        "src": "15731:12:6",
+                                                                        "stateVariable": false,
+                                                                        "storageLocation": "default",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        },
+                                                                        "typeName": {
+                                                                            "id": 5312,
+                                                                            "name": "bytes32",
+                                                                            "nodeType": "ElementaryTypeName",
+                                                                            "src": "15731:7:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "visibility": "internal"
+                                                                    }
+                                                                ],
+                                                                "id": 5321,
+                                                                "initialValue": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5316,
+                                                                            "name": "who",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5094,
+                                                                            "src": "15764:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "baseExpression": {
+                                                                                "id": 5317,
+                                                                                "name": "reads",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5186,
+                                                                                "src": "15769:5:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                    "typeString": "bytes32[] memory"
+                                                                                }
+                                                                            },
+                                                                            "id": 5319,
+                                                                            "indexExpression": {
+                                                                                "id": 5318,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5302,
+                                                                                "src": "15775:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "isConstant": false,
+                                                                            "isLValue": true,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "IndexAccess",
+                                                                            "src": "15769:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5314,
+                                                                            "name": "vm_std_store",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5066,
+                                                                            "src": "15746:12:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                "typeString": "contract Vm"
+                                                                            }
+                                                                        },
+                                                                        "id": 5315,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "load",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 6022,
+                                                                        "src": "15746:17:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$returns$_t_bytes32_$",
+                                                                            "typeString": "function (address,bytes32) external returns (bytes32)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5320,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15746:32:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    }
+                                                                },
+                                                                "nodeType": "VariableDeclarationStatement",
+                                                                "src": "15731:47:6"
+                                                            },
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    },
+                                                                    "id": 5327,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 5322,
+                                                                        "name": "prev",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5313,
+                                                                        "src": "15800:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "==",
+                                                                    "rightExpression": {
+                                                                        "arguments": [
+                                                                            {
+                                                                                "hexValue": "30",
+                                                                                "id": 5325,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": true,
+                                                                                "kind": "number",
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "Literal",
+                                                                                "src": "15816:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                                    "typeString": "int_const 0"
+                                                                                },
+                                                                                "value": "0"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "argumentTypes": [
+                                                                                {
+                                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                                    "typeString": "int_const 0"
+                                                                                }
+                                                                            ],
+                                                                            "id": 5324,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                            "src": "15808:7:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                                "typeString": "type(bytes32)"
+                                                                            },
+                                                                            "typeName": {
+                                                                                "id": 5323,
+                                                                                "name": "bytes32",
+                                                                                "nodeType": "ElementaryTypeName",
+                                                                                "src": "15808:7:6",
+                                                                                "typeDescriptions": {}
+                                                                            }
+                                                                        },
+                                                                        "id": 5326,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "typeConversion",
+                                                                        "lValueRequested": false,
+                                                                        "names": [],
+                                                                        "nodeType": "FunctionCall",
+                                                                        "src": "15808:10:6",
+                                                                        "tryCall": false,
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        }
+                                                                    },
+                                                                    "src": "15800:18:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "id": 5339,
+                                                                "nodeType": "IfStatement",
+                                                                "src": "15796:114:6",
+                                                                "trueBody": {
+                                                                    "id": 5338,
+                                                                    "nodeType": "Block",
+                                                                    "src": "15820:90:6",
+                                                                    "statements": [
+                                                                        {
+                                                                            "eventCall": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5329,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "15868:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "baseExpression": {
+                                                                                                    "id": 5332,
+                                                                                                    "name": "reads",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5186,
+                                                                                                    "src": "15881:5:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                        "typeString": "bytes32[] memory"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5334,
+                                                                                                "indexExpression": {
+                                                                                                    "id": 5333,
+                                                                                                    "name": "i",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5302,
+                                                                                                    "src": "15887:1:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_uint256",
+                                                                                                        "typeString": "uint256"
+                                                                                                    }
+                                                                                                },
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "nodeType": "IndexAccess",
+                                                                                                "src": "15881:8:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5331,
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": false,
+                                                                                            "isPure": true,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                                            "src": "15873:7:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                                "typeString": "type(uint256)"
+                                                                                            },
+                                                                                            "typeName": {
+                                                                                                "id": 5330,
+                                                                                                "name": "uint256",
+                                                                                                "nodeType": "ElementaryTypeName",
+                                                                                                "src": "15873:7:6",
+                                                                                                "typeDescriptions": {}
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5335,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "typeConversion",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "15873:17:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    ],
+                                                                                    "id": 5328,
+                                                                                    "name": "WARNING_UninitedSlot",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5049,
+                                                                                    "src": "15847:20:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                                                        "typeString": "function (address,uint256)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5336,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "15847:44:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                                    "typeString": "tuple()"
+                                                                                }
+                                                                            },
+                                                                            "id": 5337,
+                                                                            "nodeType": "EmitStatement",
+                                                                            "src": "15842:49:6"
+                                                                        }
+                                                                    ]
+                                                                }
+                                                            },
+                                                            {
+                                                                "expression": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5343,
+                                                                            "name": "who",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5094,
+                                                                            "src": "15971:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "baseExpression": {
+                                                                                "id": 5344,
+                                                                                "name": "reads",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5186,
+                                                                                "src": "15976:5:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                    "typeString": "bytes32[] memory"
+                                                                                }
+                                                                            },
+                                                                            "id": 5346,
+                                                                            "indexExpression": {
+                                                                                "id": 5345,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5302,
+                                                                                "src": "15982:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "isConstant": false,
+                                                                            "isLValue": true,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "IndexAccess",
+                                                                            "src": "15976:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "arguments": [
+                                                                                {
+                                                                                    "hexValue": "1337",
+                                                                                    "id": 5349,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "hexString",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "15994:9:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    },
+                                                                                    "value": "\u00137"
+                                                                                }
+                                                                            ],
+                                                                            "expression": {
+                                                                                "argumentTypes": [
+                                                                                    {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    }
+                                                                                ],
+                                                                                "id": 5348,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": true,
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                                "src": "15986:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                                    "typeString": "type(bytes32)"
+                                                                                },
+                                                                                "typeName": {
+                                                                                    "id": 5347,
+                                                                                    "name": "bytes32",
+                                                                                    "nodeType": "ElementaryTypeName",
+                                                                                    "src": "15986:7:6",
+                                                                                    "typeDescriptions": {}
+                                                                                }
+                                                                            },
+                                                                            "id": 5350,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "kind": "typeConversion",
+                                                                            "lValueRequested": false,
+                                                                            "names": [],
+                                                                            "nodeType": "FunctionCall",
+                                                                            "src": "15986:18:6",
+                                                                            "tryCall": false,
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5340,
+                                                                            "name": "vm_std_store",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5066,
+                                                                            "src": "15952:12:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                "typeString": "contract Vm"
+                                                                            }
+                                                                        },
+                                                                        "id": 5342,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "store",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 6031,
+                                                                        "src": "15952:18:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                                            "typeString": "function (address,bytes32,bytes32) external"
+                                                                        }
+                                                                    },
+                                                                    "id": 5351,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15952:53:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_tuple$__$",
+                                                                        "typeString": "tuple()"
+                                                                    }
+                                                                },
+                                                                "id": 5352,
+                                                                "nodeType": "ExpressionStatement",
+                                                                "src": "15952:53:6"
+                                                            },
+                                                            {
+                                                                "assignments": [
+                                                                    5354
+                                                                ],
+                                                                "declarations": [
+                                                                    {
+                                                                        "constant": false,
+                                                                        "id": 5354,
+                                                                        "mutability": "mutable",
+                                                                        "name": "success",
+                                                                        "nameLocation": "16028:7:6",
+                                                                        "nodeType": "VariableDeclaration",
+                                                                        "scope": 5468,
+                                                                        "src": "16023:12:6",
+                                                                        "stateVariable": false,
+                                                                        "storageLocation": "default",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        },
+                                                                        "typeName": {
+                                                                            "id": 5353,
+                                                                            "name": "bool",
+                                                                            "nodeType": "ElementaryTypeName",
+                                                                            "src": "16023:4:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bool",
+                                                                                "typeString": "bool"
+                                                                            }
+                                                                        },
+                                                                        "visibility": "internal"
+                                                                    }
+                                                                ],
+                                                                "id": 5355,
+                                                                "nodeType": "VariableDeclarationStatement",
+                                                                "src": "16023:12:6"
+                                                            },
+                                                            {
+                                                                "assignments": [
+                                                                    5357
+                                                                ],
+                                                                "declarations": [
+                                                                    {
+                                                                        "constant": false,
+                                                                        "id": 5357,
+                                                                        "mutability": "mutable",
+                                                                        "name": "rdat",
+                                                                        "nameLocation": "16066:4:6",
+                                                                        "nodeType": "VariableDeclaration",
+                                                                        "scope": 5468,
+                                                                        "src": "16053:17:6",
+                                                                        "stateVariable": false,
+                                                                        "storageLocation": "memory",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                            "typeString": "bytes"
+                                                                        },
+                                                                        "typeName": {
+                                                                            "id": 5356,
+                                                                            "name": "bytes",
+                                                                            "nodeType": "ElementaryTypeName",
+                                                                            "src": "16053:5:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes_storage_ptr",
+                                                                                "typeString": "bytes"
+                                                                            }
+                                                                        },
+                                                                        "visibility": "internal"
+                                                                    }
+                                                                ],
+                                                                "id": 5358,
+                                                                "nodeType": "VariableDeclarationStatement",
+                                                                "src": "16053:17:6"
+                                                            },
+                                                            {
+                                                                "id": 5377,
+                                                                "nodeType": "Block",
+                                                                "src": "16088:144:6",
+                                                                "statements": [
+                                                                    {
+                                                                        "expression": {
+                                                                            "id": 5366,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftHandSide": {
+                                                                                "components": [
+                                                                                    {
+                                                                                        "id": 5359,
+                                                                                        "name": "success",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5354,
+                                                                                        "src": "16111:7:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bool",
+                                                                                            "typeString": "bool"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "id": 5360,
+                                                                                        "name": "rdat",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5357,
+                                                                                        "src": "16120:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "id": 5361,
+                                                                                "isConstant": false,
+                                                                                "isInlineArray": false,
+                                                                                "isLValue": true,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": true,
+                                                                                "nodeType": "TupleExpression",
+                                                                                "src": "16110:15:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                                                    "typeString": "tuple(bool,bytes memory)"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "Assignment",
+                                                                            "operator": "=",
+                                                                            "rightHandSide": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5364,
+                                                                                        "name": "cald",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5148,
+                                                                                        "src": "16143:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    ],
+                                                                                    "expression": {
+                                                                                        "id": 5362,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "16128:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5363,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": false,
+                                                                                    "memberName": "staticcall",
+                                                                                    "nodeType": "MemberAccess",
+                                                                                    "src": "16128:14:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                                                        "typeString": "function (bytes memory) view returns (bool,bytes memory)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5365,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16128:20:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                                                    "typeString": "tuple(bool,bytes memory)"
+                                                                                }
+                                                                            },
+                                                                            "src": "16110:38:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_tuple$__$",
+                                                                                "typeString": "tuple()"
+                                                                            }
+                                                                        },
+                                                                        "id": 5367,
+                                                                        "nodeType": "ExpressionStatement",
+                                                                        "src": "16110:38:6"
+                                                                    },
+                                                                    {
+                                                                        "expression": {
+                                                                            "id": 5375,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftHandSide": {
+                                                                                "id": 5368,
+                                                                                "name": "fdat",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5163,
+                                                                                "src": "16170:4:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "Assignment",
+                                                                            "operator": "=",
+                                                                            "rightHandSide": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5370,
+                                                                                        "name": "rdat",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5357,
+                                                                                        "src": "16192:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "commonType": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        },
+                                                                                        "id": 5373,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "leftExpression": {
+                                                                                            "hexValue": "3332",
+                                                                                            "id": 5371,
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": false,
+                                                                                            "isPure": true,
+                                                                                            "kind": "number",
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "Literal",
+                                                                                            "src": "16198:2:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_rational_32_by_1",
+                                                                                                "typeString": "int_const 32"
+                                                                                            },
+                                                                                            "value": "32"
+                                                                                        },
+                                                                                        "nodeType": "BinaryOperation",
+                                                                                        "operator": "*",
+                                                                                        "rightExpression": {
+                                                                                            "id": 5372,
+                                                                                            "name": "field_depth",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5104,
+                                                                                            "src": "16201:11:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_uint256",
+                                                                                                "typeString": "uint256"
+                                                                                            }
+                                                                                        },
+                                                                                        "src": "16198:14:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    ],
+                                                                                    "id": 5369,
+                                                                                    "name": "bytesToBytes32",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5948,
+                                                                                    "src": "16177:14:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_internal_pure$_t_bytes_memory_ptr_$_t_uint256_$returns$_t_bytes32_$",
+                                                                                        "typeString": "function (bytes memory,uint256) pure returns (bytes32)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5374,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16177:36:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            },
+                                                                            "src": "16170:43:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "id": 5376,
+                                                                        "nodeType": "ExpressionStatement",
+                                                                        "src": "16170:43:6"
+                                                                    }
+                                                                ]
+                                                            },
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    },
+                                                                    "id": 5385,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 5378,
+                                                                        "name": "success",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5354,
+                                                                        "src": "16254:7:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "&&",
+                                                                    "rightExpression": {
+                                                                        "commonType": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        },
+                                                                        "id": 5384,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "leftExpression": {
+                                                                            "id": 5379,
+                                                                            "name": "fdat",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5163,
+                                                                            "src": "16265:4:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "nodeType": "BinaryOperation",
+                                                                        "operator": "==",
+                                                                        "rightExpression": {
+                                                                            "arguments": [
+                                                                                {
+                                                                                    "hexValue": "1337",
+                                                                                    "id": 5382,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "hexString",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "16281:9:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    },
+                                                                                    "value": "\u00137"
+                                                                                }
+                                                                            ],
+                                                                            "expression": {
+                                                                                "argumentTypes": [
+                                                                                    {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    }
+                                                                                ],
+                                                                                "id": 5381,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": true,
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                                "src": "16273:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                                    "typeString": "type(bytes32)"
+                                                                                },
+                                                                                "typeName": {
+                                                                                    "id": 5380,
+                                                                                    "name": "bytes32",
+                                                                                    "nodeType": "ElementaryTypeName",
+                                                                                    "src": "16273:7:6",
+                                                                                    "typeDescriptions": {}
+                                                                                }
+                                                                            },
+                                                                            "id": 5383,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "kind": "typeConversion",
+                                                                            "lValueRequested": false,
+                                                                            "names": [],
+                                                                            "nodeType": "FunctionCall",
+                                                                            "src": "16273:18:6",
+                                                                            "tryCall": false,
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "src": "16265:26:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        }
+                                                                    },
+                                                                    "src": "16254:37:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "id": 5457,
+                                                                "nodeType": "IfStatement",
+                                                                "src": "16250:539:6",
+                                                                "trueBody": {
+                                                                    "id": 5456,
+                                                                    "nodeType": "Block",
+                                                                    "src": "16293:496:6",
+                                                                    "statements": [
+                                                                        {
+                                                                            "eventCall": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5387,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "16399:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "id": 5388,
+                                                                                        "name": "fsig",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5099,
+                                                                                        "src": "16404:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes4",
+                                                                                            "typeString": "bytes4"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "arguments": [
+                                                                                                    {
+                                                                                                        "id": 5392,
+                                                                                                        "name": "ins",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5112,
+                                                                                                        "src": "16437:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    {
+                                                                                                        "id": 5393,
+                                                                                                        "name": "field_depth",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5104,
+                                                                                                        "src": "16442:11:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    }
+                                                                                                ],
+                                                                                                "expression": {
+                                                                                                    "argumentTypes": [
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        },
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    ],
+                                                                                                    "expression": {
+                                                                                                        "id": 5390,
+                                                                                                        "name": "abi",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": -1,
+                                                                                                        "src": "16420:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_magic_abi",
+                                                                                                            "typeString": "abi"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    "id": 5391,
+                                                                                                    "isConstant": false,
+                                                                                                    "isLValue": false,
+                                                                                                    "isPure": true,
+                                                                                                    "lValueRequested": false,
+                                                                                                    "memberName": "encodePacked",
+                                                                                                    "nodeType": "MemberAccess",
+                                                                                                    "src": "16420:16:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5394,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": false,
+                                                                                                "isPure": false,
+                                                                                                "kind": "functionCall",
+                                                                                                "lValueRequested": false,
+                                                                                                "names": [],
+                                                                                                "nodeType": "FunctionCall",
+                                                                                                "src": "16420:34:6",
+                                                                                                "tryCall": false,
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5389,
+                                                                                            "name": "keccak256",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": -8,
+                                                                                            "src": "16410:9:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5395,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "functionCall",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16410:45:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "baseExpression": {
+                                                                                                    "id": 5398,
+                                                                                                    "name": "reads",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5186,
+                                                                                                    "src": "16465:5:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                        "typeString": "bytes32[] memory"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5400,
+                                                                                                "indexExpression": {
+                                                                                                    "id": 5399,
+                                                                                                    "name": "i",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5302,
+                                                                                                    "src": "16471:1:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_uint256",
+                                                                                                        "typeString": "uint256"
+                                                                                                    }
+                                                                                                },
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "nodeType": "IndexAccess",
+                                                                                                "src": "16465:8:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5397,
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": false,
+                                                                                            "isPure": true,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                                            "src": "16457:7:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                                "typeString": "type(uint256)"
+                                                                                            },
+                                                                                            "typeName": {
+                                                                                                "id": 5396,
+                                                                                                "name": "uint256",
+                                                                                                "nodeType": "ElementaryTypeName",
+                                                                                                "src": "16457:7:6",
+                                                                                                "typeDescriptions": {}
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5401,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "typeConversion",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16457:17:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes4",
+                                                                                            "typeString": "bytes4"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    ],
+                                                                                    "id": 5386,
+                                                                                    "name": "SlotFound",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5043,
+                                                                                    "src": "16389:9:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_bytes4_$_t_bytes32_$_t_uint256_$returns$__$",
+                                                                                        "typeString": "function (address,bytes4,bytes32,uint256)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5402,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16389:86:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                                    "typeString": "tuple()"
+                                                                                }
+                                                                            },
+                                                                            "id": 5403,
+                                                                            "nodeType": "EmitStatement",
+                                                                            "src": "16384:91:6"
+                                                                        },
+                                                                        {
+                                                                            "expression": {
+                                                                                "id": 5425,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": false,
+                                                                                "leftHandSide": {
+                                                                                    "baseExpression": {
+                                                                                        "baseExpression": {
+                                                                                            "baseExpression": {
+                                                                                                "expression": {
+                                                                                                    "id": 5404,
+                                                                                                    "name": "self",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5088,
+                                                                                                    "src": "16497:4:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5415,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "memberName": "slots",
+                                                                                                "nodeType": "MemberAccess",
+                                                                                                "referencedDeclaration": 5013,
+                                                                                                "src": "16497:10:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                                                    "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                                                                }
+                                                                                            },
+                                                                                            "id": 5416,
+                                                                                            "indexExpression": {
+                                                                                                "id": 5406,
+                                                                                                "name": "who",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5094,
+                                                                                                "src": "16508:3:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_address",
+                                                                                                    "typeString": "address"
+                                                                                                }
+                                                                                            },
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": true,
+                                                                                            "isPure": false,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "IndexAccess",
+                                                                                            "src": "16497:15:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                                                                "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5417,
+                                                                                        "indexExpression": {
+                                                                                            "id": 5407,
+                                                                                            "name": "fsig",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5099,
+                                                                                            "src": "16513:4:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_bytes4",
+                                                                                                "typeString": "bytes4"
+                                                                                            }
+                                                                                        },
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": true,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "IndexAccess",
+                                                                                        "src": "16497:21:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                                                            "typeString": "mapping(bytes32 => uint256)"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5418,
+                                                                                    "indexExpression": {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "arguments": [
+                                                                                                    {
+                                                                                                        "id": 5411,
+                                                                                                        "name": "ins",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5112,
+                                                                                                        "src": "16546:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    {
+                                                                                                        "id": 5412,
+                                                                                                        "name": "field_depth",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5104,
+                                                                                                        "src": "16551:11:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    }
+                                                                                                ],
+                                                                                                "expression": {
+                                                                                                    "argumentTypes": [
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        },
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    ],
+                                                                                                    "expression": {
+                                                                                                        "id": 5409,
+                                                                                                        "name": "abi",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": -1,
+                                                                                                        "src": "16529:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_magic_abi",
+                                                                                                            "typeString": "abi"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    "id": 5410,
+                                                                                                    "isConstant": false,
+                                                                                                    "isLValue": false,
+                                                                                                    "isPure": true,
+                                                                                                    "lValueRequested": false,
+                                                                                                    "memberName": "encodePacked",
+                                                                                                    "nodeType": "MemberAccess",
+                                                                                                    "src": "16529:16:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5413,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": false,
+                                                                                                "isPure": false,
+                                                                                                "kind": "functionCall",
+                                                                                                "lValueRequested": false,
+                                                                                                "names": [],
+                                                                                                "nodeType": "FunctionCall",
+                                                                                                "src": "16529:34:6",
+                                                                                                "tryCall": false,
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5408,
+                                                                                            "name": "keccak256",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": -8,
+                                                                                            "src": "16519:9:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5414,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "functionCall",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16519:45:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": true,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": true,
+                                                                                    "nodeType": "IndexAccess",
+                                                                                    "src": "16497:68:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_uint256",
+                                                                                        "typeString": "uint256"
+                                                                                    }
+                                                                                },
+                                                                                "nodeType": "Assignment",
+                                                                                "operator": "=",
+                                                                                "rightHandSide": {
+                                                                                    "arguments": [
+                                                                                        {
+                                                                                            "baseExpression": {
+                                                                                                "id": 5421,
+                                                                                                "name": "reads",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5186,
+                                                                                                "src": "16576:5:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                    "typeString": "bytes32[] memory"
+                                                                                                }
+                                                                                            },
+                                                                                            "id": 5423,
+                                                                                            "indexExpression": {
+                                                                                                "id": 5422,
+                                                                                                "name": "i",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5302,
+                                                                                                "src": "16582:1:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_uint256",
+                                                                                                    "typeString": "uint256"
+                                                                                                }
+                                                                                            },
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": true,
+                                                                                            "isPure": false,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "IndexAccess",
+                                                                                            "src": "16576:8:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_bytes32",
+                                                                                                "typeString": "bytes32"
+                                                                                            }
+                                                                                        }
+                                                                                    ],
+                                                                                    "expression": {
+                                                                                        "argumentTypes": [
+                                                                                            {
+                                                                                                "typeIdentifier": "t_bytes32",
+                                                                                                "typeString": "bytes32"
+                                                                                            }
+                                                                                        ],
+                                                                                        "id": 5420,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": true,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                                                        "src": "16568:7:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                            "typeString": "type(uint256)"
+                                                                                        },
+                                                                                        "typeName": {
+                                                                                            "id": 5419,
+                                                                                            "name": "uint256",
+                                                                                            "nodeType": "ElementaryTypeName",
+                                                                                            "src": "16568:7:6",
+                                                                                            "typeDescriptions": {}
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5424,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": false,
+                                                                                    "kind": "typeConversion",
+                                                                                    "lValueRequested": false,
+                                                                                    "names": [],
+                                                                                    "nodeType": "FunctionCall",
+                                                                                    "src": "16568:17:6",
+                                                                                    "tryCall": false,
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_uint256",
+                                                                                        "typeString": "uint256"
+                                                                                    }
+                                                                                },
+                                                                                "src": "16497:88:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "id": 5426,
+                                                                            "nodeType": "ExpressionStatement",
+                                                                            "src": "16497:88:6"
+                                                                        },
+                                                                        {
+                                                                            "expression": {
+                                                                                "id": 5443,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": false,
+                                                                                "leftHandSide": {
+                                                                                    "baseExpression": {
+                                                                                        "baseExpression": {
+                                                                                            "baseExpression": {
+                                                                                                "expression": {
+                                                                                                    "id": 5427,
+                                                                                                    "name": "self",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5088,
+                                                                                                    "src": "16607:4:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5438,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "memberName": "finds",
+                                                                                                "nodeType": "MemberAccess",
+                                                                                                "referencedDeclaration": 5021,
+                                                                                                "src": "16607:10:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                                                                    "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                                                                }
+                                                                                            },
+                                                                                            "id": 5439,
+                                                                                            "indexExpression": {
+                                                                                                "id": 5429,
+                                                                                                "name": "who",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5094,
+                                                                                                "src": "16618:3:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_address",
+                                                                                                    "typeString": "address"
+                                                                                                }
+                                                                                            },
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": true,
+                                                                                            "isPure": false,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "IndexAccess",
+                                                                                            "src": "16607:15:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                                                                "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5440,
+                                                                                        "indexExpression": {
+                                                                                            "id": 5430,
+                                                                                            "name": "fsig",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5099,
+                                                                                            "src": "16623:4:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_bytes4",
+                                                                                                "typeString": "bytes4"
+                                                                                            }
+                                                                                        },
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": true,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "IndexAccess",
+                                                                                        "src": "16607:21:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                                                            "typeString": "mapping(bytes32 => bool)"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5441,
+                                                                                    "indexExpression": {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "arguments": [
+                                                                                                    {
+                                                                                                        "id": 5434,
+                                                                                                        "name": "ins",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5112,
+                                                                                                        "src": "16656:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    {
+                                                                                                        "id": 5435,
+                                                                                                        "name": "field_depth",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5104,
+                                                                                                        "src": "16661:11:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    }
+                                                                                                ],
+                                                                                                "expression": {
+                                                                                                    "argumentTypes": [
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        },
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    ],
+                                                                                                    "expression": {
+                                                                                                        "id": 5432,
+                                                                                                        "name": "abi",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": -1,
+                                                                                                        "src": "16639:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_magic_abi",
+                                                                                                            "typeString": "abi"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    "id": 5433,
+                                                                                                    "isConstant": false,
+                                                                                                    "isLValue": false,
+                                                                                                    "isPure": true,
+                                                                                                    "lValueRequested": false,
+                                                                                                    "memberName": "encodePacked",
+                                                                                                    "nodeType": "MemberAccess",
+                                                                                                    "src": "16639:16:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5436,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": false,
+                                                                                                "isPure": false,
+                                                                                                "kind": "functionCall",
+                                                                                                "lValueRequested": false,
+                                                                                                "names": [],
+                                                                                                "nodeType": "FunctionCall",
+                                                                                                "src": "16639:34:6",
+                                                                                                "tryCall": false,
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5431,
+                                                                                            "name": "keccak256",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": -8,
+                                                                                            "src": "16629:9:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5437,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "functionCall",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16629:45:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": true,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": true,
+                                                                                    "nodeType": "IndexAccess",
+                                                                                    "src": "16607:68:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_bool",
+                                                                                        "typeString": "bool"
+                                                                                    }
+                                                                                },
+                                                                                "nodeType": "Assignment",
+                                                                                "operator": "=",
+                                                                                "rightHandSide": {
+                                                                                    "hexValue": "74727565",
+                                                                                    "id": 5442,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "bool",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "16678:4:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_bool",
+                                                                                        "typeString": "bool"
+                                                                                    },
+                                                                                    "value": "true"
+                                                                                },
+                                                                                "src": "16607:75:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bool",
+                                                                                    "typeString": "bool"
+                                                                                }
+                                                                            },
+                                                                            "id": 5444,
+                                                                            "nodeType": "ExpressionStatement",
+                                                                            "src": "16607:75:6"
+                                                                        },
+                                                                        {
+                                                                            "expression": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5448,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "16723:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "baseExpression": {
+                                                                                            "id": 5449,
+                                                                                            "name": "reads",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5186,
+                                                                                            "src": "16728:5:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                "typeString": "bytes32[] memory"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5451,
+                                                                                        "indexExpression": {
+                                                                                            "id": 5450,
+                                                                                            "name": "i",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5302,
+                                                                                            "src": "16734:1:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_uint256",
+                                                                                                "typeString": "uint256"
+                                                                                            }
+                                                                                        },
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": true,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "IndexAccess",
+                                                                                        "src": "16728:8:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "id": 5452,
+                                                                                        "name": "prev",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5313,
+                                                                                        "src": "16738:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    ],
+                                                                                    "expression": {
+                                                                                        "id": 5445,
+                                                                                        "name": "vm_std_store",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5066,
+                                                                                        "src": "16704:12:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                            "typeString": "contract Vm"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5447,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": false,
+                                                                                    "memberName": "store",
+                                                                                    "nodeType": "MemberAccess",
+                                                                                    "referencedDeclaration": 6031,
+                                                                                    "src": "16704:18:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                                                        "typeString": "function (address,bytes32,bytes32) external"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5453,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16704:39:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                                    "typeString": "tuple()"
+                                                                                }
+                                                                            },
+                                                                            "id": 5454,
+                                                                            "nodeType": "ExpressionStatement",
+                                                                            "src": "16704:39:6"
+                                                                        },
+                                                                        {
+                                                                            "id": 5455,
+                                                                            "nodeType": "Break",
+                                                                            "src": "16765:5:6"
+                                                                        }
+                                                                    ]
+                                                                }
+                                                            },
+                                                            {
+                                                                "expression": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5461,
+                                                                            "name": "who",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5094,
+                                                                            "src": "16825:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "baseExpression": {
+                                                                                "id": 5462,
+                                                                                "name": "reads",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5186,
+                                                                                "src": "16830:5:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                    "typeString": "bytes32[] memory"
+                                                                                }
+                                                                            },
+                                                                            "id": 5464,
+                                                                            "indexExpression": {
+                                                                                "id": 5463,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5302,
+                                                                                "src": "16836:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "isConstant": false,
+                                                                            "isLValue": true,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "IndexAccess",
+                                                                            "src": "16830:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5465,
+                                                                            "name": "prev",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5313,
+                                                                            "src": "16840:4:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5458,
+                                                                            "name": "vm_std_store",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5066,
+                                                                            "src": "16806:12:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                "typeString": "contract Vm"
+                                                                            }
+                                                                        },
+                                                                        "id": 5460,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "store",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 6031,
+                                                                        "src": "16806:18:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                                            "typeString": "function (address,bytes32,bytes32) external"
+                                                                        }
+                                                                    },
+                                                                    "id": 5466,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "16806:39:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_tuple$__$",
+                                                                        "typeString": "tuple()"
+                                                                    }
+                                                                },
+                                                                "id": 5467,
+                                                                "nodeType": "ExpressionStatement",
+                                                                "src": "16806:39:6"
+                                                            }
+                                                        ]
+                                                    },
+                                                    "condition": {
+                                                        "commonType": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "id": 5308,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "leftExpression": {
+                                                            "id": 5305,
+                                                            "name": "i",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5302,
+                                                            "src": "15690:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "nodeType": "BinaryOperation",
+                                                        "operator": "<",
+                                                        "rightExpression": {
+                                                            "expression": {
+                                                                "id": 5306,
+                                                                "name": "reads",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5186,
+                                                                "src": "15694:5:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                }
+                                                            },
+                                                            "id": 5307,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "length",
+                                                            "nodeType": "MemberAccess",
+                                                            "src": "15694:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "src": "15690:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "id": 5469,
+                                                    "initializationExpression": {
+                                                        "assignments": [5302],
+                                                        "declarations": [
+                                                            {
+                                                                "constant": false,
+                                                                "id": 5302,
+                                                                "mutability": "mutable",
+                                                                "name": "i",
+                                                                "nameLocation": "15683:1:6",
+                                                                "nodeType": "VariableDeclaration",
+                                                                "scope": 5469,
+                                                                "src": "15675:9:6",
+                                                                "stateVariable": false,
+                                                                "storageLocation": "default",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 5301,
+                                                                    "name": "uint256",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "15675:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "visibility": "internal"
+                                                            }
+                                                        ],
+                                                        "id": 5304,
+                                                        "initialValue": {
+                                                            "hexValue": "30",
+                                                            "id": 5303,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "15687:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_0_by_1",
+                                                                "typeString": "int_const 0"
+                                                            },
+                                                            "value": "0"
+                                                        },
+                                                        "nodeType": "VariableDeclarationStatement",
+                                                        "src": "15675:13:6"
+                                                    },
+                                                    "loopExpression": {
+                                                        "expression": {
+                                                            "id": 5310,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "UnaryOperation",
+                                                            "operator": "++",
+                                                            "prefix": false,
+                                                            "src": "15708:3:6",
+                                                            "subExpression": {
+                                                                "id": 5309,
+                                                                "name": "i",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5302,
+                                                                "src": "15708:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "id": 5311,
+                                                        "nodeType": "ExpressionStatement",
+                                                        "src": "15708:3:6"
+                                                    },
+                                                    "nodeType": "ForStatement",
+                                                    "src": "15670:1190:6"
+                                                }
+                                            ]
+                                        }
+                                    },
+                                    "id": 5478,
+                                    "nodeType": "IfStatement",
+                                    "src": "14956:1997:6",
+                                    "trueBody": {
+                                        "id": 5296,
+                                        "nodeType": "Block",
+                                        "src": "14979:649:6",
+                                        "statements": [
+                                            {
+                                                "assignments": [5200],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 5200,
+                                                        "mutability": "mutable",
+                                                        "name": "curr",
+                                                        "nameLocation": "15001:4:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 5296,
+                                                        "src": "14993:12:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 5199,
+                                                            "name": "bytes32",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "14993:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 5208,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5203,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5094,
+                                                            "src": "15026:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        {
+                                                            "baseExpression": {
+                                                                "id": 5204,
+                                                                "name": "reads",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5186,
+                                                                "src": "15031:5:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                }
+                                                            },
+                                                            "id": 5206,
+                                                            "indexExpression": {
+                                                                "hexValue": "30",
+                                                                "id": 5205,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "15037:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                    "typeString": "int_const 0"
+                                                                },
+                                                                "value": "0"
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "15031:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 5201,
+                                                            "name": "vm_std_store",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5066,
+                                                            "src": "15008:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                "typeString": "contract Vm"
+                                                            }
+                                                        },
+                                                        "id": 5202,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "load",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 6022,
+                                                        "src": "15008:17:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$returns$_t_bytes32_$",
+                                                            "typeString": "function (address,bytes32) external returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5207,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "15008:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "14993:47:6"
+                                            },
+                                            {
+                                                "condition": {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    },
+                                                    "id": 5214,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "id": 5209,
+                                                        "name": "curr",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5200,
+                                                        "src": "15058:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "==",
+                                                    "rightExpression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "30",
+                                                                "id": 5212,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "15074:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                    "typeString": "int_const 0"
+                                                                },
+                                                                "value": "0"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                    "typeString": "int_const 0"
+                                                                }
+                                                            ],
+                                                            "id": 5211,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "15066:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                "typeString": "type(bytes32)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5210,
+                                                                "name": "bytes32",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "15066:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5213,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "15066:10:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "src": "15058:18:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 5226,
+                                                "nodeType": "IfStatement",
+                                                "src": "15054:106:6",
+                                                "trueBody": {
+                                                    "id": 5225,
+                                                    "nodeType": "Block",
+                                                    "src": "15078:82:6",
+                                                    "statements": [
+                                                        {
+                                                            "eventCall": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5216,
+                                                                        "name": "who",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5094,
+                                                                        "src": "15122:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    },
+                                                                    {
+                                                                        "arguments": [
+                                                                            {
+                                                                                "baseExpression": {
+                                                                                    "id": 5219,
+                                                                                    "name": "reads",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5186,
+                                                                                    "src": "15135:5:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                        "typeString": "bytes32[] memory"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5221,
+                                                                                "indexExpression": {
+                                                                                    "hexValue": "30",
+                                                                                    "id": 5220,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "number",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "15141:1:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_rational_0_by_1",
+                                                                                        "typeString": "int_const 0"
+                                                                                    },
+                                                                                    "value": "0"
+                                                                                },
+                                                                                "isConstant": false,
+                                                                                "isLValue": true,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "IndexAccess",
+                                                                                "src": "15135:8:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "argumentTypes": [
+                                                                                {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            ],
+                                                                            "id": 5218,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                            "src": "15127:7:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                "typeString": "type(uint256)"
+                                                                            },
+                                                                            "typeName": {
+                                                                                "id": 5217,
+                                                                                "name": "uint256",
+                                                                                "nodeType": "ElementaryTypeName",
+                                                                                "src": "15127:7:6",
+                                                                                "typeDescriptions": {}
+                                                                            }
+                                                                        },
+                                                                        "id": 5222,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "kind": "typeConversion",
+                                                                        "lValueRequested": false,
+                                                                        "names": [],
+                                                                        "nodeType": "FunctionCall",
+                                                                        "src": "15127:17:6",
+                                                                        "tryCall": false,
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        },
+                                                                        {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    ],
+                                                                    "id": 5215,
+                                                                    "name": "WARNING_UninitedSlot",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5049,
+                                                                    "src": "15101:20:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                                        "typeString": "function (address,uint256)"
+                                                                    }
+                                                                },
+                                                                "id": 5223,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "15101:44:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                    "typeString": "tuple()"
+                                                                }
+                                                            },
+                                                            "id": 5224,
+                                                            "nodeType": "EmitStatement",
+                                                            "src": "15096:49:6"
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                "condition": {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    },
+                                                    "id": 5229,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "id": 5227,
+                                                        "name": "fdat",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5163,
+                                                        "src": "15177:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "!=",
+                                                    "rightExpression": {
+                                                        "id": 5228,
+                                                        "name": "curr",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5200,
+                                                        "src": "15185:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "src": "15177:12:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 5236,
+                                                "nodeType": "IfStatement",
+                                                "src": "15173:149:6",
+                                                "trueBody": {
+                                                    "id": 5235,
+                                                    "nodeType": "Block",
+                                                    "src": "15191:131:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "hexValue": "66616c7365",
+                                                                        "id": 5231,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "bool",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "15217:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        },
+                                                                        "value": "false"
+                                                                    },
+                                                                    {
+                                                                        "hexValue": "5061636b656420736c6f742e205468697320776f756c642063617573652064616e6765726f7573206f76657277726974696e6720616e642063757272656e746c792069736e7420737570706f72746564",
+                                                                        "id": 5232,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "string",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "15224:82:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                            "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                                        },
+                                                                        "value": "Packed slot. This would cause dangerous overwriting and currently isnt supported"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        },
+                                                                        {
+                                                                            "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                            "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                                        }
+                                                                    ],
+                                                                    "id": 5230,
+                                                                    "name": "require",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [
+                                                                        -18, -18
+                                                                    ],
+                                                                    "referencedDeclaration": -18,
+                                                                    "src": "15209:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                                        "typeString": "function (bool,string memory) pure"
+                                                                    }
+                                                                },
+                                                                "id": 5233,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "15209:98:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                    "typeString": "tuple()"
+                                                                }
+                                                            },
+                                                            "id": 5234,
+                                                            "nodeType": "ExpressionStatement",
+                                                            "src": "15209:98:6"
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5238,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5094,
+                                                            "src": "15350:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        {
+                                                            "id": 5239,
+                                                            "name": "fsig",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5099,
+                                                            "src": "15355:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes4",
+                                                                "typeString": "bytes4"
+                                                            }
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5243,
+                                                                            "name": "ins",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5112,
+                                                                            "src": "15388:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5244,
+                                                                            "name": "field_depth",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5104,
+                                                                            "src": "15393:11:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5241,
+                                                                            "name": "abi",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": -1,
+                                                                            "src": "15371:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_magic_abi",
+                                                                                "typeString": "abi"
+                                                                            }
+                                                                        },
+                                                                        "id": 5242,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "encodePacked",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "src": "15371:16:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                            "typeString": "function () pure returns (bytes memory)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5245,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15371:34:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                ],
+                                                                "id": 5240,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "15361:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5246,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15361:45:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "baseExpression": {
+                                                                        "id": 5249,
+                                                                        "name": "reads",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5186,
+                                                                        "src": "15416:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                            "typeString": "bytes32[] memory"
+                                                                        }
+                                                                    },
+                                                                    "id": 5251,
+                                                                    "indexExpression": {
+                                                                        "hexValue": "30",
+                                                                        "id": 5250,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "number",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "15422:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_rational_0_by_1",
+                                                                            "typeString": "int_const 0"
+                                                                        },
+                                                                        "value": "0"
+                                                                    },
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "IndexAccess",
+                                                                    "src": "15416:8:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    }
+                                                                ],
+                                                                "id": 5248,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "15408:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_uint256_$",
+                                                                    "typeString": "type(uint256)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 5247,
+                                                                    "name": "uint256",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "15408:7:6",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 5252,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15408:17:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes4",
+                                                                "typeString": "bytes4"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 5237,
+                                                        "name": "SlotFound",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5043,
+                                                        "src": "15340:9:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_bytes4_$_t_bytes32_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (address,bytes4,bytes32,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 5253,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "15340:86:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 5254,
+                                                "nodeType": "EmitStatement",
+                                                "src": "15335:91:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 5276,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "baseExpression": {
+                                                            "baseExpression": {
+                                                                "baseExpression": {
+                                                                    "expression": {
+                                                                        "id": 5255,
+                                                                        "name": "self",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5088,
+                                                                        "src": "15440:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                            "typeString": "struct StdStorage storage pointer"
+                                                                        }
+                                                                    },
+                                                                    "id": 5266,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "slots",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5013,
+                                                                    "src": "15440:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                                    }
+                                                                },
+                                                                "id": 5267,
+                                                                "indexExpression": {
+                                                                    "id": 5257,
+                                                                    "name": "who",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5094,
+                                                                    "src": "15451:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                },
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "IndexAccess",
+                                                                "src": "15440:15:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                                }
+                                                            },
+                                                            "id": 5268,
+                                                            "indexExpression": {
+                                                                "id": 5258,
+                                                                "name": "fsig",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5099,
+                                                                "src": "15456:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes4",
+                                                                    "typeString": "bytes4"
+                                                                }
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "15440:21:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                                "typeString": "mapping(bytes32 => uint256)"
+                                                            }
+                                                        },
+                                                        "id": 5269,
+                                                        "indexExpression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5262,
+                                                                            "name": "ins",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5112,
+                                                                            "src": "15489:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5263,
+                                                                            "name": "field_depth",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5104,
+                                                                            "src": "15494:11:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5260,
+                                                                            "name": "abi",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": -1,
+                                                                            "src": "15472:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_magic_abi",
+                                                                                "typeString": "abi"
+                                                                            }
+                                                                        },
+                                                                        "id": 5261,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "encodePacked",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "src": "15472:16:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                            "typeString": "function () pure returns (bytes memory)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5264,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15472:34:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                ],
+                                                                "id": 5259,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "15462:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5265,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15462:45:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "15440:68:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "arguments": [
+                                                            {
+                                                                "baseExpression": {
+                                                                    "id": 5272,
+                                                                    "name": "reads",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5186,
+                                                                    "src": "15519:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    }
+                                                                },
+                                                                "id": 5274,
+                                                                "indexExpression": {
+                                                                    "hexValue": "30",
+                                                                    "id": 5273,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "15525:1:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_rational_0_by_1",
+                                                                        "typeString": "int_const 0"
+                                                                    },
+                                                                    "value": "0"
+                                                                },
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "IndexAccess",
+                                                                "src": "15519:8:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes32",
+                                                                    "typeString": "bytes32"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_bytes32",
+                                                                    "typeString": "bytes32"
+                                                                }
+                                                            ],
+                                                            "id": 5271,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "15511:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5270,
+                                                                "name": "uint256",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "15511:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5275,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "15511:17:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "15440:88:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 5277,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "15440:88:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 5294,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "baseExpression": {
+                                                            "baseExpression": {
+                                                                "baseExpression": {
+                                                                    "expression": {
+                                                                        "id": 5278,
+                                                                        "name": "self",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5088,
+                                                                        "src": "15542:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                            "typeString": "struct StdStorage storage pointer"
+                                                                        }
+                                                                    },
+                                                                    "id": 5289,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "finds",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5021,
+                                                                    "src": "15542:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                                    }
+                                                                },
+                                                                "id": 5290,
+                                                                "indexExpression": {
+                                                                    "id": 5280,
+                                                                    "name": "who",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5094,
+                                                                    "src": "15553:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                },
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "IndexAccess",
+                                                                "src": "15542:15:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                                }
+                                                            },
+                                                            "id": 5291,
+                                                            "indexExpression": {
+                                                                "id": 5281,
+                                                                "name": "fsig",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5099,
+                                                                "src": "15558:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes4",
+                                                                    "typeString": "bytes4"
+                                                                }
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "15542:21:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                                "typeString": "mapping(bytes32 => bool)"
+                                                            }
+                                                        },
+                                                        "id": 5292,
+                                                        "indexExpression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5285,
+                                                                            "name": "ins",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5112,
+                                                                            "src": "15591:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5286,
+                                                                            "name": "field_depth",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5104,
+                                                                            "src": "15596:11:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5283,
+                                                                            "name": "abi",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": -1,
+                                                                            "src": "15574:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_magic_abi",
+                                                                                "typeString": "abi"
+                                                                            }
+                                                                        },
+                                                                        "id": 5284,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "encodePacked",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "src": "15574:16:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                            "typeString": "function () pure returns (bytes memory)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5287,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15574:34:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                ],
+                                                                "id": 5282,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "15564:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5288,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15564:45:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "15542:68:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "74727565",
+                                                        "id": 5293,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "15613:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "true"
+                                                    },
+                                                    "src": "15542:75:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 5295,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "15542:75:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "baseExpression": {
+                                                    "baseExpression": {
+                                                        "baseExpression": {
+                                                            "expression": {
+                                                                "id": 5480,
+                                                                "name": "self",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5088,
+                                                                "src": "16971:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 5481,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "finds",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5021,
+                                                            "src": "16971:10:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                            }
+                                                        },
+                                                        "id": 5483,
+                                                        "indexExpression": {
+                                                            "id": 5482,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5094,
+                                                            "src": "16982:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "16971:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                            "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                        }
+                                                    },
+                                                    "id": 5485,
+                                                    "indexExpression": {
+                                                        "id": 5484,
+                                                        "name": "fsig",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5099,
+                                                        "src": "16987:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes4",
+                                                            "typeString": "bytes4"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "16971:21:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                        "typeString": "mapping(bytes32 => bool)"
+                                                    }
+                                                },
+                                                "id": 5493,
+                                                "indexExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "id": 5489,
+                                                                    "name": "ins",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5112,
+                                                                    "src": "17020:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    }
+                                                                },
+                                                                {
+                                                                    "id": 5490,
+                                                                    "name": "field_depth",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5104,
+                                                                    "src": "17025:11:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    },
+                                                                    {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "id": 5487,
+                                                                    "name": "abi",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": -1,
+                                                                    "src": "17003:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_magic_abi",
+                                                                        "typeString": "abi"
+                                                                    }
+                                                                },
+                                                                "id": 5488,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "memberName": "encodePacked",
+                                                                "nodeType": "MemberAccess",
+                                                                "src": "17003:16:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                    "typeString": "function () pure returns (bytes memory)"
+                                                                }
+                                                            },
+                                                            "id": 5491,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "17003:34:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 5486,
+                                                        "name": "keccak256",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -8,
+                                                        "src": "16993:9:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5492,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "16993:45:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "16971:68:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "4e6f74466f756e64",
+                                                "id": 5494,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "17041:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_a896e77af5e233b52f3d565f8bd98eec0ddb0e671485cda84d2cd93d51849a53",
+                                                    "typeString": "literal_string \"NotFound\""
+                                                },
+                                                "value": "NotFound"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_a896e77af5e233b52f3d565f8bd98eec0ddb0e671485cda84d2cd93d51849a53",
+                                                    "typeString": "literal_string \"NotFound\""
+                                                }
+                                            ],
+                                            "id": 5479,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "16963:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 5495,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "16963:89:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5496,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "16963:89:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5499,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17063:19:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5497,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17070:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5498,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_target",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5030,
+                                            "src": "17070:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5500,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17063:19:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5503,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17092:16:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5501,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17099:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5502,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "17099:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5504,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17092:16:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5507,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17118:17:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5505,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17125:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5506,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_keys",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5024,
+                                            "src": "17125:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                "typeString": "bytes32[] storage ref"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5508,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17118:17:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5511,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17145:18:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5509,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17152:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5510,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_depth",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5028,
+                                            "src": "17152:11:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5512,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17145:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "baseExpression": {
+                                            "baseExpression": {
+                                                "baseExpression": {
+                                                    "expression": {
+                                                        "id": 5513,
+                                                        "name": "self",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5088,
+                                                        "src": "17181:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 5514,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "slots",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5013,
+                                                    "src": "17181:10:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                    }
+                                                },
+                                                "id": 5516,
+                                                "indexExpression": {
+                                                    "id": 5515,
+                                                    "name": "who",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5094,
+                                                    "src": "17192:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "17181:15:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                }
+                                            },
+                                            "id": 5518,
+                                            "indexExpression": {
+                                                "id": 5517,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5099,
+                                                "src": "17197:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "IndexAccess",
+                                            "src": "17181:21:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                "typeString": "mapping(bytes32 => uint256)"
+                                            }
+                                        },
+                                        "id": 5526,
+                                        "indexExpression": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5522,
+                                                            "name": "ins",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5112,
+                                                            "src": "17230:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "id": 5523,
+                                                            "name": "field_depth",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5104,
+                                                            "src": "17235:11:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 5520,
+                                                            "name": "abi",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -1,
+                                                            "src": "17213:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_abi",
+                                                                "typeString": "abi"
+                                                            }
+                                                        },
+                                                        "id": 5521,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "memberName": "encodePacked",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "17213:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                            "typeString": "function () pure returns (bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 5524,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "17213:34:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 5519,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "17203:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 5525,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "17203:45:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "IndexAccess",
+                                        "src": "17181:68:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5092,
+                                    "id": 5527,
+                                    "nodeType": "Return",
+                                    "src": "17174:75:6"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 5085,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "13634:129:6",
+                            "text": "@notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against"
+                        },
+                        "id": 5529,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "find",
+                        "nameLocation": "14151:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5089,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5088,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "14184:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5529,
+                                    "src": "14165:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5087,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5086,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "14165:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "14165:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "14155:39:6"
+                        },
+                        "returnParameters": {
+                            "id": 5092,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5091,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5529,
+                                    "src": "14229:7:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5090,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "14229:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "14228:9:6"
+                        },
+                        "scope": 5990,
+                        "src": "14142:3114:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5548,
+                            "nodeType": "Block",
+                            "src": "17358:60:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5544,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5540,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5532,
+                                                "src": "17368:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5542,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_target",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5030,
+                                            "src": "17368:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 5543,
+                                            "name": "_target",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5534,
+                                            "src": "17383:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "src": "17368:22:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "id": 5545,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17368:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5546,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5532,
+                                        "src": "17407:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5539,
+                                    "id": 5547,
+                                    "nodeType": "Return",
+                                    "src": "17400:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5549,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "target",
+                        "nameLocation": "17271:6:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5535,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5532,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17297:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5549,
+                                    "src": "17278:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5531,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5530,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17278:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17278:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5534,
+                                    "mutability": "mutable",
+                                    "name": "_target",
+                                    "nameLocation": "17311:7:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5549,
+                                    "src": "17303:15:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5533,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17303:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17277:42:6"
+                        },
+                        "returnParameters": {
+                            "id": 5539,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5538,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5549,
+                                    "src": "17338:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5537,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5536,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17338:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17338:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17337:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17262:156:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5568,
+                            "nodeType": "Block",
+                            "src": "17513:54:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5564,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5560,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5552,
+                                                "src": "17523:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5562,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "17523:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 5563,
+                                            "name": "_sig",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5554,
+                                            "src": "17535:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "src": "17523:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "id": 5565,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17523:16:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5566,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5552,
+                                        "src": "17556:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5559,
+                                    "id": 5567,
+                                    "nodeType": "Return",
+                                    "src": "17549:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5569,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "sig",
+                        "nameLocation": "17433:3:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5555,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5552,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17456:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5569,
+                                    "src": "17437:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5551,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5550,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17437:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17437:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5554,
+                                    "mutability": "mutable",
+                                    "name": "_sig",
+                                    "nameLocation": "17469:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5569,
+                                    "src": "17462:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    },
+                                    "typeName": {
+                                        "id": 5553,
+                                        "name": "bytes4",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17462:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17436:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5559,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5558,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5569,
+                                    "src": "17493:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5557,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5556,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17493:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17493:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17492:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17424:143:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5590,
+                            "nodeType": "Block",
+                            "src": "17669:60:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5586,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5580,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5572,
+                                                "src": "17679:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5582,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "17679:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 5584,
+                                                    "name": "_sig",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5574,
+                                                    "src": "17696:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_string_memory_ptr",
+                                                        "typeString": "string memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_string_memory_ptr",
+                                                        "typeString": "string memory"
+                                                    }
+                                                ],
+                                                "id": 5583,
+                                                "name": "sigs",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5084,
+                                                "src": "17691:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_pure$_t_string_memory_ptr_$returns$_t_bytes4_$",
+                                                    "typeString": "function (string memory) pure returns (bytes4)"
+                                                }
+                                            },
+                                            "id": 5585,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "17691:10:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "src": "17679:22:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "id": 5587,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17679:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5588,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5572,
+                                        "src": "17718:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5579,
+                                    "id": 5589,
+                                    "nodeType": "Return",
+                                    "src": "17711:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5591,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "sig",
+                        "nameLocation": "17582:3:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5575,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5572,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17605:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5591,
+                                    "src": "17586:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5571,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5570,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17586:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17586:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5574,
+                                    "mutability": "mutable",
+                                    "name": "_sig",
+                                    "nameLocation": "17625:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5591,
+                                    "src": "17611:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 5573,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17611:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17585:45:6"
+                        },
+                        "returnParameters": {
+                            "id": 5579,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5578,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5591,
+                                    "src": "17649:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5577,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5576,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17649:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17649:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17648:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17573:156:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5621,
+                            "nodeType": "Block",
+                            "src": "17829:85:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5613,
+                                                                        "name": "who",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5596,
+                                                                        "src": "17879:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "id": 5612,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                                    "src": "17871:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_type$_t_uint160_$",
+                                                                        "typeString": "type(uint160)"
+                                                                    },
+                                                                    "typeName": {
+                                                                        "id": 5611,
+                                                                        "name": "uint160",
+                                                                        "nodeType": "ElementaryTypeName",
+                                                                        "src": "17871:7:6",
+                                                                        "typeDescriptions": {}
+                                                                    }
+                                                                },
+                                                                "id": 5614,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "typeConversion",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "17871:12:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            ],
+                                                            "id": 5610,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "17863:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5609,
+                                                                "name": "uint256",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "17863:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5615,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "17863:21:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5608,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "17855:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5607,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "17855:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5616,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "17855:30:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "expression": {
+                                                    "id": 5602,
+                                                    "name": "self",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5594,
+                                                    "src": "17839:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                        "typeString": "struct StdStorage storage pointer"
+                                                    }
+                                                },
+                                                "id": 5605,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "_keys",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5024,
+                                                "src": "17839:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                    "typeString": "bytes32[] storage ref"
+                                                }
+                                            },
+                                            "id": 5606,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "push",
+                                            "nodeType": "MemberAccess",
+                                            "src": "17839:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_arraypush_nonpayable$_t_array$_t_bytes32_$dyn_storage_ptr_$_t_bytes32_$returns$__$bound_to$_t_array$_t_bytes32_$dyn_storage_ptr_$",
+                                                "typeString": "function (bytes32[] storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5617,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "17839:47:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5618,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17839:47:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5619,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5594,
+                                        "src": "17903:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5601,
+                                    "id": 5620,
+                                    "nodeType": "Return",
+                                    "src": "17896:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5622,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "with_key",
+                        "nameLocation": "17744:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5597,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5594,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17772:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5622,
+                                    "src": "17753:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5593,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5592,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17753:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17753:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5596,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "17786:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5622,
+                                    "src": "17778:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5595,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17778:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17752:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5601,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5600,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5622,
+                                    "src": "17809:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5599,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5598,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17809:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17809:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17808:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17735:179:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5646,
+                            "nodeType": "Block",
+                            "src": "18014:67:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5640,
+                                                        "name": "amt",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5627,
+                                                        "src": "18048:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5639,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "18040:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5638,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "18040:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5641,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "18040:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "expression": {
+                                                    "id": 5633,
+                                                    "name": "self",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5625,
+                                                    "src": "18024:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                        "typeString": "struct StdStorage storage pointer"
+                                                    }
+                                                },
+                                                "id": 5636,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "_keys",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5024,
+                                                "src": "18024:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                    "typeString": "bytes32[] storage ref"
+                                                }
+                                            },
+                                            "id": 5637,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "push",
+                                            "nodeType": "MemberAccess",
+                                            "src": "18024:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_arraypush_nonpayable$_t_array$_t_bytes32_$dyn_storage_ptr_$_t_bytes32_$returns$__$bound_to$_t_array$_t_bytes32_$dyn_storage_ptr_$",
+                                                "typeString": "function (bytes32[] storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5642,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18024:29:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5643,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18024:29:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5644,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5625,
+                                        "src": "18070:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5632,
+                                    "id": 5645,
+                                    "nodeType": "Return",
+                                    "src": "18063:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5647,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "with_key",
+                        "nameLocation": "17929:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5628,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5625,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17957:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5647,
+                                    "src": "17938:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5624,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5623,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17938:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17938:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5627,
+                                    "mutability": "mutable",
+                                    "name": "amt",
+                                    "nameLocation": "17971:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5647,
+                                    "src": "17963:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5626,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17963:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17937:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5632,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5631,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5647,
+                                    "src": "17994:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5630,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5629,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17994:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17994:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17993:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17920:161:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5668,
+                            "nodeType": "Block",
+                            "src": "18180:58:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5663,
+                                                "name": "key",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5652,
+                                                "src": "18206:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "expression": {
+                                                    "id": 5658,
+                                                    "name": "self",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5650,
+                                                    "src": "18190:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                        "typeString": "struct StdStorage storage pointer"
+                                                    }
+                                                },
+                                                "id": 5661,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "_keys",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5024,
+                                                "src": "18190:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                    "typeString": "bytes32[] storage ref"
+                                                }
+                                            },
+                                            "id": 5662,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "push",
+                                            "nodeType": "MemberAccess",
+                                            "src": "18190:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_arraypush_nonpayable$_t_array$_t_bytes32_$dyn_storage_ptr_$_t_bytes32_$returns$__$bound_to$_t_array$_t_bytes32_$dyn_storage_ptr_$",
+                                                "typeString": "function (bytes32[] storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5664,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18190:20:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5665,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18190:20:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5666,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5650,
+                                        "src": "18227:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5657,
+                                    "id": 5667,
+                                    "nodeType": "Return",
+                                    "src": "18220:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5669,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "with_key",
+                        "nameLocation": "18095:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5653,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5650,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18123:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5669,
+                                    "src": "18104:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5649,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5648,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18104:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18104:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5652,
+                                    "mutability": "mutable",
+                                    "name": "key",
+                                    "nameLocation": "18137:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5669,
+                                    "src": "18129:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5651,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18129:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18103:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5657,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5656,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5669,
+                                    "src": "18160:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5655,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5654,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18160:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18160:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18159:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "18086:152:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5688,
+                            "nodeType": "Block",
+                            "src": "18338:58:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5684,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5680,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5672,
+                                                "src": "18348:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5682,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_depth",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5028,
+                                            "src": "18348:11:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 5683,
+                                            "name": "_depth",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5674,
+                                            "src": "18362:6:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "18348:20:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 5685,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18348:20:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5686,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5672,
+                                        "src": "18385:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5679,
+                                    "id": 5687,
+                                    "nodeType": "Return",
+                                    "src": "18378:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5689,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "depth",
+                        "nameLocation": "18253:5:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5675,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5672,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18278:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5689,
+                                    "src": "18259:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5671,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5670,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18259:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18259:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5674,
+                                    "mutability": "mutable",
+                                    "name": "_depth",
+                                    "nameLocation": "18292:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5689,
+                                    "src": "18284:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5673,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18284:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18258:41:6"
+                        },
+                        "returnParameters": {
+                            "id": 5679,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5678,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5689,
+                                    "src": "18318:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5677,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5676,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18318:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18318:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18317:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "18244:152:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5711,
+                            "nodeType": "Block",
+                            "src": "18472:68:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5698,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5692,
+                                                "src": "18496:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5705,
+                                                                        "name": "who",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5694,
+                                                                        "src": "18526:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "id": 5704,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                                    "src": "18518:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_type$_t_uint160_$",
+                                                                        "typeString": "type(uint160)"
+                                                                    },
+                                                                    "typeName": {
+                                                                        "id": 5703,
+                                                                        "name": "uint160",
+                                                                        "nodeType": "ElementaryTypeName",
+                                                                        "src": "18518:7:6",
+                                                                        "typeDescriptions": {}
+                                                                    }
+                                                                },
+                                                                "id": 5706,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "typeConversion",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "18518:12:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            ],
+                                                            "id": 5702,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "18510:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5701,
+                                                                "name": "uint256",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "18510:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5707,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "18510:21:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5700,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "18502:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5699,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "18502:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5708,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "18502:30:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5697,
+                                            "name": "checked_write",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                5712, 5729, 5747, 5892
+                                            ],
+                                            "referencedDeclaration": 5892,
+                                            "src": "18482:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (struct StdStorage storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5709,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18482:51:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5710,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18482:51:6"
+                                }
+                            ]
+                        },
+                        "id": 5712,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18411:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5695,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5692,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18444:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5712,
+                                    "src": "18425:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5691,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5690,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18425:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18425:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5694,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "18458:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5712,
+                                    "src": "18450:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5693,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18450:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18424:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5696,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18472:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18402:138:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5728,
+                            "nodeType": "Block",
+                            "src": "18616:50:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5721,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5715,
+                                                "src": "18640:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5724,
+                                                        "name": "amt",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5717,
+                                                        "src": "18654:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5723,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "18646:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5722,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "18646:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5725,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "18646:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5720,
+                                            "name": "checked_write",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                5712, 5729, 5747, 5892
+                                            ],
+                                            "referencedDeclaration": 5892,
+                                            "src": "18626:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (struct StdStorage storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5726,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18626:33:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5727,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18626:33:6"
+                                }
+                            ]
+                        },
+                        "id": 5729,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18555:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5718,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5715,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18588:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5729,
+                                    "src": "18569:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5714,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5713,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18569:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18569:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5717,
+                                    "mutability": "mutable",
+                                    "name": "amt",
+                                    "nameLocation": "18602:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5729,
+                                    "src": "18594:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5716,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18594:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18568:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5719,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18616:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18546:120:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5746,
+                            "nodeType": "Block",
+                            "src": "18741:153:6",
+                            "statements": [
+                                {
+                                    "assignments": [5738],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5738,
+                                            "mutability": "mutable",
+                                            "name": "t",
+                                            "nameLocation": "18759:1:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5746,
+                                            "src": "18751:9:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5737,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "18751:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5739,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "18751:9:6"
+                                },
+                                {
+                                    "AST": {
+                                        "nodeType": "YulBlock",
+                                        "src": "18822:34:6",
+                                        "statements": [
+                                            {
+                                                "nodeType": "YulAssignment",
+                                                "src": "18836:10:6",
+                                                "value": {
+                                                    "name": "write",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "18841:5:6"
+                                                },
+                                                "variableNames": [
+                                                    {
+                                                        "name": "t",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "18836:1:6"
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    },
+                                    "documentation": "@solidity memory-safe-assembly",
+                                    "evmVersion": "london",
+                                    "externalReferences": [
+                                        {
+                                            "declaration": 5738,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "18836:1:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 5734,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "18841:5:6",
+                                            "valueSize": 1
+                                        }
+                                    ],
+                                    "id": 5740,
+                                    "nodeType": "InlineAssembly",
+                                    "src": "18813:43:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5742,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5732,
+                                                "src": "18879:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            {
+                                                "id": 5743,
+                                                "name": "t",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5738,
+                                                "src": "18885:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5741,
+                                            "name": "checked_write",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                5712, 5729, 5747, 5892
+                                            ],
+                                            "referencedDeclaration": 5892,
+                                            "src": "18865:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (struct StdStorage storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5744,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18865:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5745,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18865:22:6"
+                                }
+                            ]
+                        },
+                        "id": 5747,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18681:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5735,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5732,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18714:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5747,
+                                    "src": "18695:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5731,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5730,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18695:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18695:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5734,
+                                    "mutability": "mutable",
+                                    "name": "write",
+                                    "nameLocation": "18725:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5747,
+                                    "src": "18720:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 5733,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18720:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18694:37:6"
+                        },
+                        "returnParameters": {
+                            "id": 5736,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18741:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18672:222:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5891,
+                            "nodeType": "Block",
+                            "src": "18992:966:6",
+                            "statements": [
+                                {
+                                    "assignments": [5756],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5756,
+                                            "mutability": "mutable",
+                                            "name": "who",
+                                            "nameLocation": "19010:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19002:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            },
+                                            "typeName": {
+                                                "id": 5755,
+                                                "name": "address",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19002:7:6",
+                                                "stateMutability": "nonpayable",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5759,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5757,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19016:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5758,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_target",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5030,
+                                        "src": "19016:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19002:26:6"
+                                },
+                                {
+                                    "assignments": [5761],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5761,
+                                            "mutability": "mutable",
+                                            "name": "fsig",
+                                            "nameLocation": "19045:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19038:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            },
+                                            "typeName": {
+                                                "id": 5760,
+                                                "name": "bytes4",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19038:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5764,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5762,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19052:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5763,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_sig",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5026,
+                                        "src": "19052:9:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19038:23:6"
+                                },
+                                {
+                                    "assignments": [5766],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5766,
+                                            "mutability": "mutable",
+                                            "name": "field_depth",
+                                            "nameLocation": "19079:11:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19071:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 5765,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19071:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5769,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5767,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19093:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5768,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_depth",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5028,
+                                        "src": "19093:11:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19071:33:6"
+                                },
+                                {
+                                    "assignments": [5774],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5774,
+                                            "mutability": "mutable",
+                                            "name": "ins",
+                                            "nameLocation": "19131:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19114:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                "typeString": "bytes32[]"
+                                            },
+                                            "typeName": {
+                                                "baseType": {
+                                                    "id": 5772,
+                                                    "name": "bytes32",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "19114:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5773,
+                                                "nodeType": "ArrayTypeName",
+                                                "src": "19114:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                                    "typeString": "bytes32[]"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5777,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5775,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19137:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5776,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_keys",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5024,
+                                        "src": "19137:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                            "typeString": "bytes32[] storage ref"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19114:33:6"
+                                },
+                                {
+                                    "assignments": [5779],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5779,
+                                            "mutability": "mutable",
+                                            "name": "cald",
+                                            "nameLocation": "19171:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19158:17:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 5778,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19158:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5787,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 5782,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5761,
+                                                "src": "19195:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5784,
+                                                        "name": "ins",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5774,
+                                                        "src": "19209:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    ],
+                                                    "id": 5783,
+                                                    "name": "flatten",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5989,
+                                                    "src": "19201:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_pure$_t_array$_t_bytes32_$dyn_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes32[] memory) pure returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5785,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "19201:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5780,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "19178:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 5781,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "encodePacked",
+                                            "nodeType": "MemberAccess",
+                                            "src": "19178:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function () pure returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 5786,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19178:36:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19158:56:6"
+                                },
+                                {
+                                    "condition": {
+                                        "id": 5802,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "!",
+                                        "prefix": true,
+                                        "src": "19228:69:6",
+                                        "subExpression": {
+                                            "baseExpression": {
+                                                "baseExpression": {
+                                                    "baseExpression": {
+                                                        "expression": {
+                                                            "id": 5788,
+                                                            "name": "self",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5750,
+                                                            "src": "19229:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        },
+                                                        "id": 5789,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "finds",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 5021,
+                                                        "src": "19229:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                            "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                        }
+                                                    },
+                                                    "id": 5791,
+                                                    "indexExpression": {
+                                                        "id": 5790,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5756,
+                                                        "src": "19240:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "19229:15:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                        "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                    }
+                                                },
+                                                "id": 5793,
+                                                "indexExpression": {
+                                                    "id": 5792,
+                                                    "name": "fsig",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5761,
+                                                    "src": "19245:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes4",
+                                                        "typeString": "bytes4"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "19229:21:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                    "typeString": "mapping(bytes32 => bool)"
+                                                }
+                                            },
+                                            "id": 5801,
+                                            "indexExpression": {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "id": 5797,
+                                                                "name": "ins",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5774,
+                                                                "src": "19278:3:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                }
+                                                            },
+                                                            {
+                                                                "id": 5798,
+                                                                "name": "field_depth",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5766,
+                                                                "src": "19283:11:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                },
+                                                                {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "id": 5795,
+                                                                "name": "abi",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -1,
+                                                                "src": "19261:3:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_magic_abi",
+                                                                    "typeString": "abi"
+                                                                }
+                                                            },
+                                                            "id": 5796,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "memberName": "encodePacked",
+                                                            "nodeType": "MemberAccess",
+                                                            "src": "19261:16:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                "typeString": "function () pure returns (bytes memory)"
+                                                            }
+                                                        },
+                                                        "id": 5799,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "19261:34:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "id": 5794,
+                                                    "name": "keccak256",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": -8,
+                                                    "src": "19251:9:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                        "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                    }
+                                                },
+                                                "id": 5800,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "19251:45:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "IndexAccess",
+                                            "src": "19229:68:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5808,
+                                    "nodeType": "IfStatement",
+                                    "src": "19224:110:6",
+                                    "trueBody": {
+                                        "id": 5807,
+                                        "nodeType": "Block",
+                                        "src": "19299:35:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5804,
+                                                            "name": "self",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5750,
+                                                            "src": "19318:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        ],
+                                                        "id": 5803,
+                                                        "name": "find",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5529,
+                                                        "src": "19313:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$returns$_t_uint256_$",
+                                                            "typeString": "function (struct StdStorage storage pointer) returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 5805,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19313:10:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 5806,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "19313:10:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "assignments": [5810],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5810,
+                                            "mutability": "mutable",
+                                            "name": "slot",
+                                            "nameLocation": "19351:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19343:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5809,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19343:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5828,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "baseExpression": {
+                                                    "baseExpression": {
+                                                        "baseExpression": {
+                                                            "expression": {
+                                                                "id": 5813,
+                                                                "name": "self",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5750,
+                                                                "src": "19366:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 5814,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "slots",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5013,
+                                                            "src": "19366:10:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                            }
+                                                        },
+                                                        "id": 5816,
+                                                        "indexExpression": {
+                                                            "id": 5815,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5756,
+                                                            "src": "19377:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "19366:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                            "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                        }
+                                                    },
+                                                    "id": 5818,
+                                                    "indexExpression": {
+                                                        "id": 5817,
+                                                        "name": "fsig",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5761,
+                                                        "src": "19382:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes4",
+                                                            "typeString": "bytes4"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "19366:21:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                        "typeString": "mapping(bytes32 => uint256)"
+                                                    }
+                                                },
+                                                "id": 5826,
+                                                "indexExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "id": 5822,
+                                                                    "name": "ins",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5774,
+                                                                    "src": "19415:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    }
+                                                                },
+                                                                {
+                                                                    "id": 5823,
+                                                                    "name": "field_depth",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5766,
+                                                                    "src": "19420:11:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    },
+                                                                    {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "id": 5820,
+                                                                    "name": "abi",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": -1,
+                                                                    "src": "19398:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_magic_abi",
+                                                                        "typeString": "abi"
+                                                                    }
+                                                                },
+                                                                "id": 5821,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "memberName": "encodePacked",
+                                                                "nodeType": "MemberAccess",
+                                                                "src": "19398:16:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                    "typeString": "function () pure returns (bytes memory)"
+                                                                }
+                                                            },
+                                                            "id": 5824,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "19398:34:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 5819,
+                                                        "name": "keccak256",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -8,
+                                                        "src": "19388:9:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5825,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19388:45:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "19366:68:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "id": 5812,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "nodeType": "ElementaryTypeNameExpression",
+                                            "src": "19358:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_type$_t_bytes32_$",
+                                                "typeString": "type(bytes32)"
+                                            },
+                                            "typeName": {
+                                                "id": 5811,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19358:7:6",
+                                                "typeDescriptions": {}
+                                            }
+                                        },
+                                        "id": 5827,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "typeConversion",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19358:77:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19343:92:6"
+                                },
+                                {
+                                    "assignments": [5830],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5830,
+                                            "mutability": "mutable",
+                                            "name": "fdat",
+                                            "nameLocation": "19454:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19446:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5829,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19446:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5831,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19446:12:6"
+                                },
+                                {
+                                    "id": 5848,
+                                    "nodeType": "Block",
+                                    "src": "19468:126:6",
+                                    "statements": [
+                                        {
+                                            "assignments": [null, 5833],
+                                            "declarations": [
+                                                null,
+                                                {
+                                                    "constant": false,
+                                                    "id": 5833,
+                                                    "mutability": "mutable",
+                                                    "name": "rdat",
+                                                    "nameLocation": "19498:4:6",
+                                                    "nodeType": "VariableDeclaration",
+                                                    "scope": 5848,
+                                                    "src": "19485:17:6",
+                                                    "stateVariable": false,
+                                                    "storageLocation": "memory",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5832,
+                                                        "name": "bytes",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "19485:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                                            "typeString": "bytes"
+                                                        }
+                                                    },
+                                                    "visibility": "internal"
+                                                }
+                                            ],
+                                            "id": 5838,
+                                            "initialValue": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5836,
+                                                        "name": "cald",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5779,
+                                                        "src": "19521:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 5834,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5756,
+                                                        "src": "19506:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    },
+                                                    "id": 5835,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "staticcall",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "19506:14:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes memory) view returns (bool,bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5837,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "19506:20:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                    "typeString": "tuple(bool,bytes memory)"
+                                                }
+                                            },
+                                            "nodeType": "VariableDeclarationStatement",
+                                            "src": "19482:44:6"
+                                        },
+                                        {
+                                            "expression": {
+                                                "id": 5846,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftHandSide": {
+                                                    "id": 5839,
+                                                    "name": "fdat",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5830,
+                                                    "src": "19540:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "Assignment",
+                                                "operator": "=",
+                                                "rightHandSide": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5841,
+                                                            "name": "rdat",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5833,
+                                                            "src": "19562:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "commonType": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            "id": 5844,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "leftExpression": {
+                                                                "hexValue": "3332",
+                                                                "id": 5842,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "19568:2:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_32_by_1",
+                                                                    "typeString": "int_const 32"
+                                                                },
+                                                                "value": "32"
+                                                            },
+                                                            "nodeType": "BinaryOperation",
+                                                            "operator": "*",
+                                                            "rightExpression": {
+                                                                "id": 5843,
+                                                                "name": "field_depth",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5766,
+                                                                "src": "19571:11:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "src": "19568:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 5840,
+                                                        "name": "bytesToBytes32",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5948,
+                                                        "src": "19547:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_pure$_t_bytes_memory_ptr_$_t_uint256_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory,uint256) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5845,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19547:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "src": "19540:43:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "id": 5847,
+                                            "nodeType": "ExpressionStatement",
+                                            "src": "19540:43:6"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "assignments": [5850],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5850,
+                                            "mutability": "mutable",
+                                            "name": "curr",
+                                            "nameLocation": "19611:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19603:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5849,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19603:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5856,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 5853,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5756,
+                                                "src": "19636:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 5854,
+                                                "name": "slot",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5810,
+                                                "src": "19641:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5851,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "19618:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5852,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "load",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6022,
+                                            "src": "19618:17:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$returns$_t_bytes32_$",
+                                                "typeString": "function (address,bytes32) external returns (bytes32)"
+                                            }
+                                        },
+                                        "id": 5855,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19618:28:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19603:43:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        },
+                                        "id": 5859,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 5857,
+                                            "name": "fdat",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5830,
+                                            "src": "19661:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "id": 5858,
+                                            "name": "curr",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5850,
+                                            "src": "19669:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "src": "19661:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5866,
+                                    "nodeType": "IfStatement",
+                                    "src": "19657:141:6",
+                                    "trueBody": {
+                                        "id": 5865,
+                                        "nodeType": "Block",
+                                        "src": "19675:123:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "66616c7365",
+                                                            "id": 5861,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "bool",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "19697:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bool",
+                                                                "typeString": "bool"
+                                                            },
+                                                            "value": "false"
+                                                        },
+                                                        {
+                                                            "hexValue": "5061636b656420736c6f742e205468697320776f756c642063617573652064616e6765726f7573206f76657277726974696e6720616e642063757272656e746c792069736e7420737570706f72746564",
+                                                            "id": 5862,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "19704:82:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                            },
+                                                            "value": "Packed slot. This would cause dangerous overwriting and currently isnt supported"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bool",
+                                                                "typeString": "bool"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                            }
+                                                        ],
+                                                        "id": 5860,
+                                                        "name": "require",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [
+                                                            -18, -18
+                                                        ],
+                                                        "referencedDeclaration": -18,
+                                                        "src": "19689:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (bool,string memory) pure"
+                                                        }
+                                                    },
+                                                    "id": 5863,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19689:98:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 5864,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "19689:98:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5870,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5756,
+                                                "src": "19826:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 5871,
+                                                "name": "slot",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5810,
+                                                "src": "19831:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            {
+                                                "id": 5872,
+                                                "name": "set",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5752,
+                                                "src": "19837:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5867,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "19807:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5869,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "store",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6031,
+                                            "src": "19807:18:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (address,bytes32,bytes32) external"
+                                            }
+                                        },
+                                        "id": 5873,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19807:34:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5874,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19807:34:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5877,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19851:19:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5875,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19858:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5876,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_target",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5030,
+                                            "src": "19858:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5878,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19851:19:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5881,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19880:16:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5879,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19887:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5880,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "19887:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5882,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19880:16:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5885,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19906:17:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5883,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19913:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5884,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_keys",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5024,
+                                            "src": "19913:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                "typeString": "bytes32[] storage ref"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5886,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19906:17:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5889,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19933:18:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5887,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19940:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5888,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_depth",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5028,
+                                            "src": "19940:11:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5890,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19933:18:6"
+                                }
+                            ]
+                        },
+                        "id": 5892,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18909:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5753,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5750,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18951:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5892,
+                                    "src": "18932:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5749,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5748,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18932:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18932:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5752,
+                                    "mutability": "mutable",
+                                    "name": "set",
+                                    "nameLocation": "18973:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5892,
+                                    "src": "18965:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5751,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18965:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18922:60:6"
+                        },
+                        "returnParameters": {
+                            "id": 5754,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18992:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18900:1058:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5947,
+                            "nodeType": "Block",
+                            "src": "20047:214:6",
+                            "statements": [
+                                {
+                                    "assignments": [5902],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5902,
+                                            "mutability": "mutable",
+                                            "name": "out",
+                                            "nameLocation": "20065:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5947,
+                                            "src": "20057:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5901,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20057:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5903,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "20057:11:6"
+                                },
+                                {
+                                    "assignments": [5905],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5905,
+                                            "mutability": "mutable",
+                                            "name": "max",
+                                            "nameLocation": "20087:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5947,
+                                            "src": "20079:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 5904,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20079:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5914,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 5909,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "expression": {
+                                                    "id": 5906,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5894,
+                                                    "src": "20093:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                },
+                                                "id": 5907,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "length",
+                                                "nodeType": "MemberAccess",
+                                                "src": "20093:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "hexValue": "3332",
+                                                "id": 5908,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "20104:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_32_by_1",
+                                                    "typeString": "int_const 32"
+                                                },
+                                                "value": "32"
+                                            },
+                                            "src": "20093:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "expression": {
+                                                "id": 5911,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5894,
+                                                "src": "20114:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            },
+                                            "id": 5912,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "length",
+                                            "nodeType": "MemberAccess",
+                                            "src": "20114:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 5913,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "20093:29:6",
+                                        "trueExpression": {
+                                            "hexValue": "3332",
+                                            "id": 5910,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "20109:2:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_32_by_1",
+                                                "typeString": "int_const 32"
+                                            },
+                                            "value": "32"
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "20079:43:6"
+                                },
+                                {
+                                    "body": {
+                                        "id": 5943,
+                                        "nodeType": "Block",
+                                        "src": "20163:72:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "id": 5941,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "id": 5925,
+                                                        "name": "out",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5902,
+                                                        "src": "20177:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "|=",
+                                                    "rightHandSide": {
+                                                        "commonType": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        },
+                                                        "id": 5940,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "leftExpression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_bytes1",
+                                                                        "typeString": "bytes1"
+                                                                    },
+                                                                    "id": 5934,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "baseExpression": {
+                                                                            "id": 5928,
+                                                                            "name": "b",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5894,
+                                                                            "src": "20192:1:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                "typeString": "bytes memory"
+                                                                            }
+                                                                        },
+                                                                        "id": 5932,
+                                                                        "indexExpression": {
+                                                                            "commonType": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            },
+                                                                            "id": 5931,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftExpression": {
+                                                                                "id": 5929,
+                                                                                "name": "offset",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5896,
+                                                                                "src": "20194:6:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "BinaryOperation",
+                                                                            "operator": "+",
+                                                                            "rightExpression": {
+                                                                                "id": 5930,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5916,
+                                                                                "src": "20203:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "src": "20194:10:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        },
+                                                                        "isConstant": false,
+                                                                        "isLValue": true,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "IndexAccess",
+                                                                        "src": "20192:13:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes1",
+                                                                            "typeString": "bytes1"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "&",
+                                                                    "rightExpression": {
+                                                                        "hexValue": "30784646",
+                                                                        "id": 5933,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "number",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "20208:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_rational_255_by_1",
+                                                                            "typeString": "int_const 255"
+                                                                        },
+                                                                        "value": "0xFF"
+                                                                    },
+                                                                    "src": "20192:20:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes1",
+                                                                        "typeString": "bytes1"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes1",
+                                                                        "typeString": "bytes1"
+                                                                    }
+                                                                ],
+                                                                "id": 5927,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "20184:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                    "typeString": "type(bytes32)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 5926,
+                                                                    "name": "bytes32",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "20184:7:6",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 5935,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "20184:29:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "nodeType": "BinaryOperation",
+                                                        "operator": ">>",
+                                                        "rightExpression": {
+                                                            "components": [
+                                                                {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 5938,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 5936,
+                                                                        "name": "i",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5916,
+                                                                        "src": "20218:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "*",
+                                                                    "rightExpression": {
+                                                                        "hexValue": "38",
+                                                                        "id": 5937,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "number",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "20222:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_rational_8_by_1",
+                                                                            "typeString": "int_const 8"
+                                                                        },
+                                                                        "value": "8"
+                                                                    },
+                                                                    "src": "20218:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "id": 5939,
+                                                            "isConstant": false,
+                                                            "isInlineArray": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "TupleExpression",
+                                                            "src": "20217:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "src": "20184:40:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "src": "20177:47:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5942,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "20177:47:6"
+                                            }
+                                        ]
+                                    },
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 5921,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 5919,
+                                            "name": "i",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5916,
+                                            "src": "20149:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "<",
+                                        "rightExpression": {
+                                            "id": 5920,
+                                            "name": "max",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5905,
+                                            "src": "20153:3:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "20149:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5944,
+                                    "initializationExpression": {
+                                        "assignments": [5916],
+                                        "declarations": [
+                                            {
+                                                "constant": false,
+                                                "id": 5916,
+                                                "mutability": "mutable",
+                                                "name": "i",
+                                                "nameLocation": "20142:1:6",
+                                                "nodeType": "VariableDeclaration",
+                                                "scope": 5944,
+                                                "src": "20137:6:6",
+                                                "stateVariable": false,
+                                                "storageLocation": "default",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "typeName": {
+                                                    "id": 5915,
+                                                    "name": "uint",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "20137:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "visibility": "internal"
+                                            }
+                                        ],
+                                        "id": 5918,
+                                        "initialValue": {
+                                            "hexValue": "30",
+                                            "id": 5917,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "20146:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "nodeType": "VariableDeclarationStatement",
+                                        "src": "20137:10:6"
+                                    },
+                                    "loopExpression": {
+                                        "expression": {
+                                            "id": 5923,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "UnaryOperation",
+                                            "operator": "++",
+                                            "prefix": false,
+                                            "src": "20158:3:6",
+                                            "subExpression": {
+                                                "id": 5922,
+                                                "name": "i",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5916,
+                                                "src": "20158:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 5924,
+                                        "nodeType": "ExpressionStatement",
+                                        "src": "20158:3:6"
+                                    },
+                                    "nodeType": "ForStatement",
+                                    "src": "20132:103:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5945,
+                                        "name": "out",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5902,
+                                        "src": "20251:3:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5900,
+                                    "id": 5946,
+                                    "nodeType": "Return",
+                                    "src": "20244:10:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "53584939",
+                        "id": 5948,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "bytesToBytes32",
+                        "nameLocation": "19973:14:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5897,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5894,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "20001:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5948,
+                                    "src": "19988:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 5893,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "19988:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5896,
+                                    "mutability": "mutable",
+                                    "name": "offset",
+                                    "nameLocation": "20009:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5948,
+                                    "src": "20004:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5895,
+                                        "name": "uint",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "20004:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "19987:29:6"
+                        },
+                        "returnParameters": {
+                            "id": 5900,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5899,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5948,
+                                    "src": "20038:7:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5898,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "20038:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "20037:9:6"
+                        },
+                        "scope": 5990,
+                        "src": "19964:297:6",
+                        "stateMutability": "pure",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 5988,
+                            "nodeType": "Block",
+                            "src": "20344:320:6",
+                            "statements": [
+                                {
+                                    "assignments": [5957],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5957,
+                                            "mutability": "mutable",
+                                            "name": "result",
+                                            "nameLocation": "20367:6:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5988,
+                                            "src": "20354:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 5956,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20354:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5965,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 5963,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 5960,
+                                                        "name": "b",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5951,
+                                                        "src": "20386:1:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    },
+                                                    "id": 5961,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "length",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "20386:8:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "*",
+                                                "rightExpression": {
+                                                    "hexValue": "3332",
+                                                    "id": 5962,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "20397:2:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_32_by_1",
+                                                        "typeString": "int_const 32"
+                                                    },
+                                                    "value": "32"
+                                                },
+                                                "src": "20386:13:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "id": 5959,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "nodeType": "NewExpression",
+                                            "src": "20376:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_objectcreation_pure$_t_uint256_$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function (uint256) pure returns (bytes memory)"
+                                            },
+                                            "typeName": {
+                                                "id": 5958,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20380:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            }
+                                        },
+                                        "id": 5964,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "20376:24:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "20354:46:6"
+                                },
+                                {
+                                    "body": {
+                                        "id": 5984,
+                                        "nodeType": "Block",
+                                        "src": "20449:185:6",
+                                        "statements": [
+                                            {
+                                                "assignments": [5978],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 5978,
+                                                        "mutability": "mutable",
+                                                        "name": "k",
+                                                        "nameLocation": "20471:1:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 5984,
+                                                        "src": "20463:9:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 5977,
+                                                            "name": "bytes32",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "20463:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 5982,
+                                                "initialValue": {
+                                                    "baseExpression": {
+                                                        "id": 5979,
+                                                        "name": "b",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5951,
+                                                        "src": "20475:1:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    },
+                                                    "id": 5981,
+                                                    "indexExpression": {
+                                                        "id": 5980,
+                                                        "name": "i",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5967,
+                                                        "src": "20477:1:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "20475:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "20463:16:6"
+                                            },
+                                            {
+                                                "AST": {
+                                                    "nodeType": "YulBlock",
+                                                    "src": "20549:75:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "arguments": [
+                                                                            {
+                                                                                "name": "result",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "20578:6:6"
+                                                                            },
+                                                                            {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "kind": "number",
+                                                                                        "nodeType": "YulLiteral",
+                                                                                        "src": "20590:2:6",
+                                                                                        "type": "",
+                                                                                        "value": "32"
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "kind": "number",
+                                                                                                "nodeType": "YulLiteral",
+                                                                                                "src": "20598:2:6",
+                                                                                                "type": "",
+                                                                                                "value": "32"
+                                                                                            },
+                                                                                            {
+                                                                                                "name": "i",
+                                                                                                "nodeType": "YulIdentifier",
+                                                                                                "src": "20602:1:6"
+                                                                                            }
+                                                                                        ],
+                                                                                        "functionName": {
+                                                                                            "name": "mul",
+                                                                                            "nodeType": "YulIdentifier",
+                                                                                            "src": "20594:3:6"
+                                                                                        },
+                                                                                        "nodeType": "YulFunctionCall",
+                                                                                        "src": "20594:10:6"
+                                                                                    }
+                                                                                ],
+                                                                                "functionName": {
+                                                                                    "name": "add",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "20586:3:6"
+                                                                                },
+                                                                                "nodeType": "YulFunctionCall",
+                                                                                "src": "20586:19:6"
+                                                                            }
+                                                                        ],
+                                                                        "functionName": {
+                                                                            "name": "add",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "20574:3:6"
+                                                                        },
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "20574:32:6"
+                                                                    },
+                                                                    {
+                                                                        "name": "k",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "20608:1:6"
+                                                                    }
+                                                                ],
+                                                                "functionName": {
+                                                                    "name": "mstore",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "20567:6:6"
+                                                                },
+                                                                "nodeType": "YulFunctionCall",
+                                                                "src": "20567:43:6"
+                                                            },
+                                                            "nodeType": "YulExpressionStatement",
+                                                            "src": "20567:43:6"
+                                                        }
+                                                    ]
+                                                },
+                                                "documentation": "@solidity memory-safe-assembly",
+                                                "evmVersion": "london",
+                                                "externalReferences": [
+                                                    {
+                                                        "declaration": 5967,
+                                                        "isOffset": false,
+                                                        "isSlot": false,
+                                                        "src": "20602:1:6",
+                                                        "valueSize": 1
+                                                    },
+                                                    {
+                                                        "declaration": 5978,
+                                                        "isOffset": false,
+                                                        "isSlot": false,
+                                                        "src": "20608:1:6",
+                                                        "valueSize": 1
+                                                    },
+                                                    {
+                                                        "declaration": 5957,
+                                                        "isOffset": false,
+                                                        "isSlot": false,
+                                                        "src": "20578:6:6",
+                                                        "valueSize": 1
+                                                    }
+                                                ],
+                                                "id": 5983,
+                                                "nodeType": "InlineAssembly",
+                                                "src": "20540:84:6"
+                                            }
+                                        ]
+                                    },
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 5973,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 5970,
+                                            "name": "i",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5967,
+                                            "src": "20430:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "<",
+                                        "rightExpression": {
+                                            "expression": {
+                                                "id": 5971,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5951,
+                                                "src": "20434:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                    "typeString": "bytes32[] memory"
+                                                }
+                                            },
+                                            "id": 5972,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "length",
+                                            "nodeType": "MemberAccess",
+                                            "src": "20434:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "20430:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5985,
+                                    "initializationExpression": {
+                                        "assignments": [5967],
+                                        "declarations": [
+                                            {
+                                                "constant": false,
+                                                "id": 5967,
+                                                "mutability": "mutable",
+                                                "name": "i",
+                                                "nameLocation": "20423:1:6",
+                                                "nodeType": "VariableDeclaration",
+                                                "scope": 5985,
+                                                "src": "20415:9:6",
+                                                "stateVariable": false,
+                                                "storageLocation": "default",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "typeName": {
+                                                    "id": 5966,
+                                                    "name": "uint256",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "20415:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "visibility": "internal"
+                                            }
+                                        ],
+                                        "id": 5969,
+                                        "initialValue": {
+                                            "hexValue": "30",
+                                            "id": 5968,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "20427:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "nodeType": "VariableDeclarationStatement",
+                                        "src": "20415:13:6"
+                                    },
+                                    "loopExpression": {
+                                        "expression": {
+                                            "id": 5975,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "UnaryOperation",
+                                            "operator": "++",
+                                            "prefix": false,
+                                            "src": "20444:3:6",
+                                            "subExpression": {
+                                                "id": 5974,
+                                                "name": "i",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5967,
+                                                "src": "20444:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 5976,
+                                        "nodeType": "ExpressionStatement",
+                                        "src": "20444:3:6"
+                                    },
+                                    "nodeType": "ForStatement",
+                                    "src": "20410:224:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5986,
+                                        "name": "result",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5957,
+                                        "src": "20651:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5955,
+                                    "id": 5987,
+                                    "nodeType": "Return",
+                                    "src": "20644:13:6"
+                                }
+                            ]
+                        },
+                        "id": 5989,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "flatten",
+                        "nameLocation": "20276:7:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5952,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5951,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "20301:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5989,
+                                    "src": "20284:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                        "typeString": "bytes32[]"
+                                    },
+                                    "typeName": {
+                                        "baseType": {
+                                            "id": 5949,
+                                            "name": "bytes32",
+                                            "nodeType": "ElementaryTypeName",
+                                            "src": "20284:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "id": 5950,
+                                        "nodeType": "ArrayTypeName",
+                                        "src": "20284:9:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                            "typeString": "bytes32[]"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "20283:20:6"
+                        },
+                        "returnParameters": {
+                            "id": 5955,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5954,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5989,
+                                    "src": "20326:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 5953,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "20326:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "20325:14:6"
+                        },
+                        "scope": 5990,
+                        "src": "20267:397:6",
+                        "stateMutability": "pure",
+                        "virtual": false,
+                        "visibility": "private"
+                    }
+                ],
+                "scope": 5991,
+                "src": "13204:7462:6",
+                "usedErrors": []
+            }
+        ],
+        "src": "38:20629:6"
+    }
+}
diff --git a/out/Test.sol/stdStorage.json b/out/Test.sol/stdStorage.json
new file mode 100644
index 0000000..eec4422
--- /dev/null
+++ b/out/Test.sol/stdStorage.json
@@ -0,0 +1,28740 @@
+{
+    "abi": [
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "address",
+                    "name": "who",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "bytes4",
+                    "name": "fsig",
+                    "type": "bytes4"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "bytes32",
+                    "name": "keysHash",
+                    "type": "bytes32"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "slot",
+                    "type": "uint256"
+                }
+            ],
+            "name": "SlotFound",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "address",
+                    "name": "who",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "slot",
+                    "type": "uint256"
+                }
+            ],
+            "name": "WARNING_UninitedSlot",
+            "type": "event"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "b",
+                    "type": "bytes"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "offset",
+                    "type": "uint256"
+                }
+            ],
+            "name": "bytesToBytes32",
+            "outputs": [
+                {
+                    "internalType": "bytes32",
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "stateMutability": "pure",
+            "type": "function"
+        }
+    ],
+    "bytecode": {
+        "object": "0x61025b61003a600b82828239805160001a60731461002d57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106100355760003560e01c8063535849391461003a575b600080fd5b61004d6100483660046100f2565b61005f565b60405190815260200160405180910390f35b60008060006020855111610074578451610077565b60205b905060005b818110156100d25761008f8160086101bd565b8661009a83886101dc565b815181106100aa576100aa6101f4565b01602001516001600160f81b031916901c9290921791806100ca8161020a565b91505061007c565b5090949350505050565b634e487b7160e01b600052604160045260246000fd5b6000806040838503121561010557600080fd5b823567ffffffffffffffff8082111561011d57600080fd5b818501915085601f83011261013157600080fd5b813581811115610143576101436100dc565b604051601f8201601f19908116603f0116810190838211818310171561016b5761016b6100dc565b8160405282815288602084870101111561018457600080fd5b826020860160208301376000602093820184015298969091013596505050505050565b634e487b7160e01b600052601160045260246000fd5b60008160001904831182151516156101d7576101d76101a7565b500290565b600082198211156101ef576101ef6101a7565b500190565b634e487b7160e01b600052603260045260246000fd5b600060001982141561021e5761021e6101a7565b506001019056fea264697066735822122048c64812d3830411f93c65e22afdc29eca25bff8aea766ff32befd09bb836cf964736f6c634300080a0033",
+        "sourceMap": "13204:7462:6:-:0;;;;;;;;;;;;;;;-1:-1:-1;;;13204:7462:6;;;;;;;;;;;;;;;;;",
+        "linkReferences": {}
+    },
+    "deployedBytecode": {
+        "object": "0x73000000000000000000000000000000000000000030146080604052600436106100355760003560e01c8063535849391461003a575b600080fd5b61004d6100483660046100f2565b61005f565b60405190815260200160405180910390f35b60008060006020855111610074578451610077565b60205b905060005b818110156100d25761008f8160086101bd565b8661009a83886101dc565b815181106100aa576100aa6101f4565b01602001516001600160f81b031916901c9290921791806100ca8161020a565b91505061007c565b5090949350505050565b634e487b7160e01b600052604160045260246000fd5b6000806040838503121561010557600080fd5b823567ffffffffffffffff8082111561011d57600080fd5b818501915085601f83011261013157600080fd5b813581811115610143576101436100dc565b604051601f8201601f19908116603f0116810190838211818310171561016b5761016b6100dc565b8160405282815288602084870101111561018457600080fd5b826020860160208301376000602093820184015298969091013596505050505050565b634e487b7160e01b600052601160045260246000fd5b60008160001904831182151516156101d7576101d76101a7565b500290565b600082198211156101ef576101ef6101a7565b500190565b634e487b7160e01b600052603260045260246000fd5b600060001982141561021e5761021e6101a7565b506001019056fea264697066735822122048c64812d3830411f93c65e22afdc29eca25bff8aea766ff32befd09bb836cf964736f6c634300080a0033",
+        "sourceMap": "13204:7462:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;19964:297;;;;;;:::i;:::-;;:::i;:::-;;;1304:25:27;;;1292:2;1277:18;19964:297:6;;;;;;;;20038:7;20057:11;20079;20104:2;20093:1;:8;:13;:29;;20114:1;:8;20093:29;;;20109:2;20093:29;20079:43;;20137:6;20132:103;20153:3;20149:1;:7;20132:103;;;20218:5;:1;20222;20218:5;:::i;:::-;20192:1;20194:10;20203:1;20194:6;:10;:::i;:::-;20192:13;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;20192:13:6;20184:40;;20177:47;;;;;20158:3;;;;:::i;:::-;;;;20132:103;;;-1:-1:-1;20251:3:6;;19964:297;-1:-1:-1;;;;19964:297:6:o;14:127:27:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:999;223:6;231;284:2;272:9;263:7;259:23;255:32;252:52;;;300:1;297;290:12;252:52;340:9;327:23;369:18;410:2;402:6;399:14;396:34;;;426:1;423;416:12;396:34;464:6;453:9;449:22;439:32;;509:7;502:4;498:2;494:13;490:27;480:55;;531:1;528;521:12;480:55;567:2;554:16;589:2;585;582:10;579:36;;;595:18;;:::i;:::-;670:2;664:9;638:2;724:13;;-1:-1:-1;;720:22:27;;;744:2;716:31;712:40;700:53;;;768:18;;;788:22;;;765:46;762:72;;;814:18;;:::i;:::-;854:10;850:2;843:22;889:2;881:6;874:18;931:7;924:4;919:2;915;911:11;907:22;904:35;901:55;;;952:1;949;942:12;901:55;1012:2;1005:4;1001:2;997:13;990:4;982:6;978:17;965:50;1059:1;1052:4;1035:15;;;1031:26;;1024:37;1035:15;1118:20;;;;1105:34;;-1:-1:-1;;;;;;146:999:27:o;1340:127::-;1401:10;1396:3;1392:20;1389:1;1382:31;1432:4;1429:1;1422:15;1456:4;1453:1;1446:15;1472:168;1512:7;1578:1;1574;1570:6;1566:14;1563:1;1560:21;1555:1;1548:9;1541:17;1537:45;1534:71;;;1585:18;;:::i;:::-;-1:-1:-1;1625:9:27;;1472:168::o;1645:128::-;1685:3;1716:1;1712:6;1709:1;1706:13;1703:39;;;1722:18;;:::i;:::-;-1:-1:-1;1758:9:27;;1645:128::o;1778:127::-;1839:10;1834:3;1830:20;1827:1;1820:31;1870:4;1867:1;1860:15;1894:4;1891:1;1884:15;1910:135;1949:3;-1:-1:-1;;1970:17:27;;1967:43;;;1990:18;;:::i;:::-;-1:-1:-1;2037:1:27;2026:13;;1910:135::o",
+        "linkReferences": {}
+    },
+    "ast": {
+        "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/Test.sol",
+        "exportedSymbols": {
+            "DSTest": [3806],
+            "StdStorage": [5033],
+            "Test": [4935],
+            "Vm": [6200],
+            "console": [14264],
+            "console2": [22328],
+            "stdError": [5005],
+            "stdStorage": [5990]
+        },
+        "id": 5991,
+        "license": "Unlicense",
+        "nodeType": "SourceUnit",
+        "nodes": [
+            {
+                "id": 3808,
+                "literals": ["solidity", ">=", "0.6", ".0", "<", "0.9", ".0"],
+                "nodeType": "PragmaDirective",
+                "src": "38:31:6"
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/Vm.sol",
+                "file": "./Vm.sol",
+                "id": 3809,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 6201,
+                "src": "71:18:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/lib/ds-test/src/test.sol",
+                "file": "../lib/ds-test/src/test.sol",
+                "id": 3810,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 3807,
+                "src": "90:37:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/console.sol",
+                "file": "./console.sol",
+                "id": 3811,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 14265,
+                "src": "128:23:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/console2.sol",
+                "file": "./console2.sol",
+                "id": 3812,
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "ImportDirective",
+                "scope": 5991,
+                "sourceUnit": 22329,
+                "src": "152:24:6",
+                "symbolAliases": [],
+                "unitAlias": ""
+            },
+            {
+                "abstract": true,
+                "baseContracts": [
+                    {
+                        "baseName": {
+                            "id": 3813,
+                            "name": "DSTest",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 3806,
+                            "src": "252:6:6"
+                        },
+                        "id": 3814,
+                        "nodeType": "InheritanceSpecifier",
+                        "src": "252:6:6"
+                    }
+                ],
+                "canonicalName": "Test",
+                "contractDependencies": [],
+                "contractKind": "contract",
+                "fullyImplemented": true,
+                "id": 4935,
+                "linearizedBaseContracts": [4935, 3806],
+                "name": "Test",
+                "nameLocation": "244:4:6",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "id": 3818,
+                        "libraryName": {
+                            "id": 3815,
+                            "name": "stdStorage",
+                            "nodeType": "IdentifierPath",
+                            "referencedDeclaration": 5990,
+                            "src": "271:10:6"
+                        },
+                        "nodeType": "UsingForDirective",
+                        "src": "265:32:6",
+                        "typeName": {
+                            "id": 3817,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 3816,
+                                "name": "StdStorage",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 5033,
+                                "src": "286:10:6"
+                            },
+                            "referencedDeclaration": 5033,
+                            "src": "286:10:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                "typeString": "struct StdStorage"
+                            }
+                        }
+                    },
+                    {
+                        "anonymous": false,
+                        "id": 3822,
+                        "name": "WARNING_Deprecated",
+                        "nameLocation": "309:18:6",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 3821,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3820,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "msg",
+                                    "nameLocation": "335:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3822,
+                                    "src": "328:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 3819,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "328:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "327:12:6"
+                        },
+                        "src": "303:37:6"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "3a768463",
+                        "id": 3828,
+                        "mutability": "constant",
+                        "name": "vm",
+                        "nameLocation": "365:2:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 4935,
+                        "src": "346:40:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_Vm_$6200",
+                            "typeString": "contract Vm"
+                        },
+                        "typeName": {
+                            "id": 3824,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 3823,
+                                "name": "Vm",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6200,
+                                "src": "346:2:6"
+                            },
+                            "referencedDeclaration": 6200,
+                            "src": "346:2:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "id": 3826,
+                                    "name": "HEVM_ADDRESS",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": 2127,
+                                    "src": "373:12:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                ],
+                                "id": 3825,
+                                "name": "Vm",
+                                "nodeType": "Identifier",
+                                "overloadedDeclarations": [],
+                                "referencedDeclaration": 6200,
+                                "src": "370:2:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_contract$_Vm_$6200_$",
+                                    "typeString": "type(contract Vm)"
+                                }
+                            },
+                            "id": 3827,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "370:16:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": false,
+                        "id": 3831,
+                        "mutability": "mutable",
+                        "name": "stdstore",
+                        "nameLocation": "412:8:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 4935,
+                        "src": "392:28:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                            "typeString": "struct StdStorage"
+                        },
+                        "typeName": {
+                            "id": 3830,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 3829,
+                                "name": "StdStorage",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 5033,
+                                "src": "392:10:6"
+                            },
+                            "referencedDeclaration": 5033,
+                            "src": "392:10:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                "typeString": "struct StdStorage"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 3845,
+                            "nodeType": "Block",
+                            "src": "743:48:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 3842,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 3839,
+                                                        "name": "block",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -4,
+                                                        "src": "761:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_magic_block",
+                                                            "typeString": "block"
+                                                        }
+                                                    },
+                                                    "id": 3840,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "timestamp",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "761:15:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "+",
+                                                "rightExpression": {
+                                                    "id": 3841,
+                                                    "name": "time",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 3833,
+                                                    "src": "779:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "761:22:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3836,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "753:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3838,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "warp",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5998,
+                                            "src": "753:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$returns$__$",
+                                                "typeString": "function (uint256) external"
+                                            }
+                                        },
+                                        "id": 3843,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "753:31:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3844,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "753:31:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "b9c071b4",
+                        "id": 3846,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "skip",
+                        "nameLocation": "717:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3834,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3833,
+                                    "mutability": "mutable",
+                                    "name": "time",
+                                    "nameLocation": "730:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3846,
+                                    "src": "722:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3832,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "722:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "721:14:6"
+                        },
+                        "returnParameters": {
+                            "id": 3835,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "743:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "708:83:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3860,
+                            "nodeType": "Block",
+                            "src": "834:48:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 3857,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 3854,
+                                                        "name": "block",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -4,
+                                                        "src": "852:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_magic_block",
+                                                            "typeString": "block"
+                                                        }
+                                                    },
+                                                    "id": 3855,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "timestamp",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "852:15:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "-",
+                                                "rightExpression": {
+                                                    "id": 3856,
+                                                    "name": "time",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 3848,
+                                                    "src": "870:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "src": "852:22:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3851,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "844:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3853,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "warp",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5998,
+                                            "src": "844:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_uint256_$returns$__$",
+                                                "typeString": "function (uint256) external"
+                                            }
+                                        },
+                                        "id": 3858,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "844:31:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3859,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "844:31:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "2d6c17a3",
+                        "id": 3861,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "rewind",
+                        "nameLocation": "806:6:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3849,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3848,
+                                    "mutability": "mutable",
+                                    "name": "time",
+                                    "nameLocation": "821:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3861,
+                                    "src": "813:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3847,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "813:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "812:14:6"
+                        },
+                        "returnParameters": {
+                            "id": 3850,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "834:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "797:85:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3881,
+                            "nodeType": "Block",
+                            "src": "979:62:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3869,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3863,
+                                                "src": "997:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 3872,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 3870,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1002:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 3871,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1007:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1002:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3866,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "989:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3868,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "989:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3873,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "989:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3874,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "989:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3878,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3863,
+                                                "src": "1030:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3875,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1021:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3877,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6078,
+                                            "src": "1021:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3879,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1021:13:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3880,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1021:13:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "233240ee",
+                        "id": 3882,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "954:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3864,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3863,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "967:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3882,
+                                    "src": "959:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3862,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "959:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "958:13:6"
+                        },
+                        "returnParameters": {
+                            "id": 3865,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "979:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "945:96:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3902,
+                            "nodeType": "Block",
+                            "src": "1095:58:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3892,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3884,
+                                                "src": "1113:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3893,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3886,
+                                                "src": "1118:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3889,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1105:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3891,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1105:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3894,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1105:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3895,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1105:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3899,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3884,
+                                                "src": "1142:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3896,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1133:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3898,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6078,
+                                            "src": "1133:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3900,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1133:13:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3901,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1133:13:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "e9a79a7b",
+                        "id": 3903,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "1056:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3887,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3884,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1069:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3903,
+                                    "src": "1061:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3883,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1061:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3886,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "1082:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3903,
+                                    "src": "1074:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3885,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1074:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1060:27:6"
+                        },
+                        "returnParameters": {
+                            "id": 3888,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1095:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1047:106:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3926,
+                            "nodeType": "Block",
+                            "src": "1209:70:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3913,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3905,
+                                                "src": "1227:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 3916,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 3914,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1232:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 3915,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1237:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1232:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3910,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1219:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3912,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1219:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3917,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1219:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3918,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1219:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3922,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3905,
+                                                "src": "1260:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3923,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3907,
+                                                "src": "1265:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3919,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1251:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3921,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6090,
+                                            "src": "1251:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 3924,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1251:21:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3925,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1251:21:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "29a9e300",
+                        "id": 3927,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "1168:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3908,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3905,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1181:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3927,
+                                    "src": "1173:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3904,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1173:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3907,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "1194:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3927,
+                                    "src": "1186:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3906,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1186:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1172:29:6"
+                        },
+                        "returnParameters": {
+                            "id": 3909,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1209:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1159:120:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3950,
+                            "nodeType": "Block",
+                            "src": "1349:66:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3939,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3929,
+                                                "src": "1367:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3940,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3933,
+                                                "src": "1372:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3936,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1359:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3938,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1359:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3941,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1359:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3942,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1359:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3946,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3929,
+                                                "src": "1396:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3947,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3931,
+                                                "src": "1401:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3943,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1387:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3945,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "prank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6090,
+                                            "src": "1387:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 3948,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1387:21:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3949,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1387:21:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "af9bbe5f",
+                        "id": 3951,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "hoax",
+                        "nameLocation": "1294:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3934,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3929,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1307:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3951,
+                                    "src": "1299:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3928,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1299:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3931,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "1320:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3951,
+                                    "src": "1312:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3930,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1312:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3933,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "1336:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3951,
+                                    "src": "1328:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3932,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1328:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1298:43:6"
+                        },
+                        "returnParameters": {
+                            "id": 3935,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1349:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1285:130:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3971,
+                            "nodeType": "Block",
+                            "src": "1525:67:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3959,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3953,
+                                                "src": "1543:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 3962,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 3960,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1548:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 3961,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1553:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1548:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3956,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1535:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3958,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1535:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3963,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1535:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3964,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1535:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3968,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3953,
+                                                "src": "1581:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3965,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1567:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3967,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6083,
+                                            "src": "1567:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3969,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1567:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3970,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1567:18:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "6f597075",
+                        "id": 3972,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1495:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3954,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3953,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1513:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3972,
+                                    "src": "1505:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3952,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1505:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1504:13:6"
+                        },
+                        "returnParameters": {
+                            "id": 3955,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1525:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1486:106:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 3992,
+                            "nodeType": "Block",
+                            "src": "1651:63:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3982,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3974,
+                                                "src": "1669:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 3983,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3976,
+                                                "src": "1674:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3979,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1661:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3981,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1661:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 3984,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1661:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3985,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1661:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 3989,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3974,
+                                                "src": "1703:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 3986,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1689:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 3988,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6083,
+                                            "src": "1689:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$__$",
+                                                "typeString": "function (address) external"
+                                            }
+                                        },
+                                        "id": 3990,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1689:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 3991,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1689:18:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "108554f2",
+                        "id": 3993,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1607:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3977,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3974,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1625:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3993,
+                                    "src": "1617:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3973,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1617:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3976,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "1638:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 3993,
+                                    "src": "1630:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 3975,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1630:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1616:27:6"
+                        },
+                        "returnParameters": {
+                            "id": 3978,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1651:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1598:116:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4016,
+                            "nodeType": "Block",
+                            "src": "1888:75:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4003,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3995,
+                                                "src": "1906:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                },
+                                                "id": 4006,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "hexValue": "31",
+                                                    "id": 4004,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1911:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_1_by_1",
+                                                        "typeString": "int_const 1"
+                                                    },
+                                                    "value": "1"
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "<<",
+                                                "rightExpression": {
+                                                    "hexValue": "313238",
+                                                    "id": 4005,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "1916:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_128_by_1",
+                                                        "typeString": "int_const 128"
+                                                    },
+                                                    "value": "128"
+                                                },
+                                                "src": "1911:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_rational_340282366920938463463374607431768211456_by_1",
+                                                    "typeString": "int_const 3402...(31 digits omitted)...1456"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4000,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1898:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4002,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "1898:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 4007,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1898:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4008,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1898:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4012,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3995,
+                                                "src": "1944:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4013,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3997,
+                                                "src": "1949:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4009,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "1930:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4011,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6097,
+                                            "src": "1930:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 4014,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "1930:26:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4015,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "1930:26:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "d06d8229",
+                        "id": 4017,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1842:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 3998,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 3995,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1860:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4017,
+                                    "src": "1852:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3994,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1852:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 3997,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "1873:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4017,
+                                    "src": "1865:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 3996,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1865:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1851:29:6"
+                        },
+                        "returnParameters": {
+                            "id": 3999,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1888:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1833:130:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4040,
+                            "nodeType": "Block",
+                            "src": "2038:71:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4029,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4019,
+                                                "src": "2056:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4030,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4023,
+                                                "src": "2061:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4026,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "2048:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4028,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "2048:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 4031,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2048:18:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4032,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2048:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4036,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4019,
+                                                "src": "2090:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4037,
+                                                "name": "origin",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4021,
+                                                "src": "2095:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4033,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "2076:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4035,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "startPrank",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6097,
+                                            "src": "2076:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$returns$__$",
+                                                "typeString": "function (address,address) external"
+                                            }
+                                        },
+                                        "id": 4038,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2076:26:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4039,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2076:26:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "3bf82db1",
+                        "id": 4041,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startHoax",
+                        "nameLocation": "1978:9:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4024,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4019,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "1996:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4041,
+                                    "src": "1988:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4018,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1988:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4021,
+                                    "mutability": "mutable",
+                                    "name": "origin",
+                                    "nameLocation": "2009:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4041,
+                                    "src": "2001:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4020,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2001:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4023,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2025:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4041,
+                                    "src": "2017:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4022,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2017:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1987:43:6"
+                        },
+                        "returnParameters": {
+                            "id": 4025,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2038:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "1969:140:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4069,
+                            "nodeType": "Block",
+                            "src": "2214:236:6",
+                            "statements": [
+                                {
+                                    "eventCall": {
+                                        "arguments": [
+                                            {
+                                                "hexValue": "54686520607469706020737464636865617420686173206265656e20646570726563617465642e2055736520606465616c6020696e73746561642e",
+                                                "id": 4051,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2248:61:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_744a6c098d7a732288220a904d49fcc88d2e3ed1ffdf88ffc87b900c86d281d4",
+                                                    "typeString": "literal_string \"The `tip` stdcheat has been deprecated. Use `deal` instead.\""
+                                                },
+                                                "value": "The `tip` stdcheat has been deprecated. Use `deal` instead."
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_744a6c098d7a732288220a904d49fcc88d2e3ed1ffdf88ffc87b900c86d281d4",
+                                                    "typeString": "literal_string \"The `tip` stdcheat has been deprecated. Use `deal` instead.\""
+                                                }
+                                            ],
+                                            "id": 4050,
+                                            "name": "WARNING_Deprecated",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 3822,
+                                            "src": "2229:18:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (string memory)"
+                                            }
+                                        },
+                                        "id": 4052,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2229:81:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4053,
+                                    "nodeType": "EmitStatement",
+                                    "src": "2224:86:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4066,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4047,
+                                                "src": "2438:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 4063,
+                                                        "name": "to",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4045,
+                                                        "src": "2407:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "30783730613038323331",
+                                                                "id": 4060,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "2373:10:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                },
+                                                                "value": "0x70a08231"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 4057,
+                                                                        "name": "token",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4043,
+                                                                        "src": "2349:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "id": 4054,
+                                                                        "name": "stdstore",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 3831,
+                                                                        "src": "2320:8:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                                                                            "typeString": "struct StdStorage storage ref"
+                                                                        }
+                                                                    },
+                                                                    "id": 4056,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "target",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5549,
+                                                                    "src": "2320:28:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                                    }
+                                                                },
+                                                                "id": 4058,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "2320:35:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 4059,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "sig",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5569,
+                                                            "src": "2320:52:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes4_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                "typeString": "function (struct StdStorage storage pointer,bytes4) returns (struct StdStorage storage pointer)"
+                                                            }
+                                                        },
+                                                        "id": 4061,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "2320:64:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 4062,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "with_key",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5622,
+                                                    "src": "2320:86:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                    }
+                                                },
+                                                "id": 4064,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "2320:90:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 4065,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "checked_write",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5729,
+                                            "src": "2320:117:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_uint256_$returns$__$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                "typeString": "function (struct StdStorage storage pointer,uint256)"
+                                            }
+                                        },
+                                        "id": 4067,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2320:123:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4068,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2320:123:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "d82555f1",
+                        "id": 4070,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "tip",
+                        "nameLocation": "2162:3:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4048,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4043,
+                                    "mutability": "mutable",
+                                    "name": "token",
+                                    "nameLocation": "2174:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4070,
+                                    "src": "2166:13:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4042,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2166:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4045,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2189:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4070,
+                                    "src": "2181:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4044,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2181:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4047,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2201:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4070,
+                                    "src": "2193:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4046,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2193:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2165:41:6"
+                        },
+                        "returnParameters": {
+                            "id": 4049,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2214:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2153:297:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4084,
+                            "nodeType": "Block",
+                            "src": "2590:34:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4080,
+                                                "name": "to",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4072,
+                                                "src": "2608:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4081,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4074,
+                                                "src": "2612:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4077,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "2600:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4079,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "deal",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6107,
+                                            "src": "2600:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                "typeString": "function (address,uint256) external"
+                                            }
+                                        },
+                                        "id": 4082,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2600:17:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4083,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2600:17:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "c88a5e6d",
+                        "id": 4085,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deal",
+                        "nameLocation": "2552:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4075,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4072,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2565:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4085,
+                                    "src": "2557:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4071,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2557:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4074,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2577:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4085,
+                                    "src": "2569:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4073,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2569:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2556:26:6"
+                        },
+                        "returnParameters": {
+                            "id": 4076,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2590:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2543:81:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4101,
+                            "nodeType": "Block",
+                            "src": "2810:45:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4095,
+                                                "name": "token",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4087,
+                                                "src": "2825:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4096,
+                                                "name": "to",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4089,
+                                                "src": "2832:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 4097,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4091,
+                                                "src": "2836:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "66616c7365",
+                                                "id": 4098,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "2842:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "false"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 4094,
+                                            "name": "deal",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                4085, 4102, 4205
+                                            ],
+                                            "referencedDeclaration": 4205,
+                                            "src": "2820:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$_t_bool_$returns$__$",
+                                                "typeString": "function (address,address,uint256,bool)"
+                                            }
+                                        },
+                                        "id": 4099,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "2820:28:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4100,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "2820:28:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "6bce989b",
+                        "id": 4102,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deal",
+                        "nameLocation": "2757:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4092,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4087,
+                                    "mutability": "mutable",
+                                    "name": "token",
+                                    "nameLocation": "2770:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4102,
+                                    "src": "2762:13:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4086,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2762:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4089,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2785:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4102,
+                                    "src": "2777:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4088,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2777:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4091,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2797:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4102,
+                                    "src": "2789:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4090,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2789:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2761:41:6"
+                        },
+                        "returnParameters": {
+                            "id": 4093,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2810:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2748:107:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4204,
+                            "nodeType": "Block",
+                            "src": "2936:840:6",
+                            "statements": [
+                                {
+                                    "assignments": [null, 4114],
+                                    "declarations": [
+                                        null,
+                                        {
+                                            "constant": false,
+                                            "id": 4114,
+                                            "mutability": "mutable",
+                                            "name": "balData",
+                                            "nameLocation": "2993:7:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4204,
+                                            "src": "2980:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 4113,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "2980:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4123,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "hexValue": "30783730613038323331",
+                                                        "id": 4119,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "3038:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1889567281_by_1",
+                                                            "typeString": "int_const 1889567281"
+                                                        },
+                                                        "value": "0x70a08231"
+                                                    },
+                                                    {
+                                                        "id": 4120,
+                                                        "name": "to",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4106,
+                                                        "src": "3050:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_rational_1889567281_by_1",
+                                                            "typeString": "int_const 1889567281"
+                                                        },
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 4117,
+                                                        "name": "abi",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -1,
+                                                        "src": "3015:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_magic_abi",
+                                                            "typeString": "abi"
+                                                        }
+                                                    },
+                                                    "id": 4118,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "memberName": "encodeWithSelector",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "3015:22:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_abiencodewithselector_pure$_t_bytes4_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes4) pure returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 4121,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3015:38:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4115,
+                                                "name": "token",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4104,
+                                                "src": "3004:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            "id": 4116,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "call",
+                                            "nodeType": "MemberAccess",
+                                            "src": "3004:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_barecall_payable$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                "typeString": "function (bytes memory) payable returns (bool,bytes memory)"
+                                            }
+                                        },
+                                        "id": 4122,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3004:50:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                            "typeString": "tuple(bool,bytes memory)"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "2977:77:6"
+                                },
+                                {
+                                    "assignments": [4125],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4125,
+                                            "mutability": "mutable",
+                                            "name": "prevBal",
+                                            "nameLocation": "3072:7:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4204,
+                                            "src": "3064:15:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4124,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "3064:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4133,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 4128,
+                                                "name": "balData",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4114,
+                                                "src": "3093:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            },
+                                            {
+                                                "components": [
+                                                    {
+                                                        "id": 4130,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "3103:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_uint256_$",
+                                                            "typeString": "type(uint256)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 4129,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "3103:7:6",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    }
+                                                ],
+                                                "id": 4131,
+                                                "isConstant": false,
+                                                "isInlineArray": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "nodeType": "TupleExpression",
+                                                "src": "3102:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_uint256_$",
+                                                    "typeString": "type(uint256)"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_type$_t_uint256_$",
+                                                    "typeString": "type(uint256)"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4126,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "3082:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 4127,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "decode",
+                                            "nodeType": "MemberAccess",
+                                            "src": "3082:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abidecode_pure$__$returns$__$",
+                                                "typeString": "function () pure"
+                                            }
+                                        },
+                                        "id": 4132,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3082:30:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "3064:48:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4146,
+                                                "name": "give",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4108,
+                                                "src": "3267:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 4143,
+                                                        "name": "to",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4106,
+                                                        "src": "3236:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "30783730613038323331",
+                                                                "id": 4140,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "3202:10:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                },
+                                                                "value": "0x70a08231"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_rational_1889567281_by_1",
+                                                                    "typeString": "int_const 1889567281"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 4137,
+                                                                        "name": "token",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4104,
+                                                                        "src": "3178:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "id": 4134,
+                                                                        "name": "stdstore",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 3831,
+                                                                        "src": "3149:8:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                                                                            "typeString": "struct StdStorage storage ref"
+                                                                        }
+                                                                    },
+                                                                    "id": 4136,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "target",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5549,
+                                                                    "src": "3149:28:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                                    }
+                                                                },
+                                                                "id": 4138,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "3149:35:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 4139,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "sig",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5569,
+                                                            "src": "3149:52:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes4_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                "typeString": "function (struct StdStorage storage pointer,bytes4) returns (struct StdStorage storage pointer)"
+                                                            }
+                                                        },
+                                                        "id": 4141,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "3149:64:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 4142,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "with_key",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5622,
+                                                    "src": "3149:86:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                        "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                    }
+                                                },
+                                                "id": 4144,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "3149:90:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 4145,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "checked_write",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5729,
+                                            "src": "3149:117:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_uint256_$returns$__$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                "typeString": "function (struct StdStorage storage pointer,uint256)"
+                                            }
+                                        },
+                                        "id": 4147,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "3149:123:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4148,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "3149:123:6"
+                                },
+                                {
+                                    "condition": {
+                                        "id": 4149,
+                                        "name": "adjust",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 4110,
+                                        "src": "3317:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4203,
+                                    "nodeType": "IfStatement",
+                                    "src": "3314:456:6",
+                                    "trueBody": {
+                                        "id": 4202,
+                                        "nodeType": "Block",
+                                        "src": "3324:446:6",
+                                        "statements": [
+                                            {
+                                                "assignments": [null, 4151],
+                                                "declarations": [
+                                                    null,
+                                                    {
+                                                        "constant": false,
+                                                        "id": 4151,
+                                                        "mutability": "mutable",
+                                                        "name": "totSupData",
+                                                        "nameLocation": "3354:10:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 4202,
+                                                        "src": "3341:23:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "memory",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 4150,
+                                                            "name": "bytes",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "3341:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_storage_ptr",
+                                                                "typeString": "bytes"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 4159,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "30783138313630646464",
+                                                                    "id": 4156,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "3402:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    },
+                                                                    "value": "0x18160ddd"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "id": 4154,
+                                                                    "name": "abi",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": -1,
+                                                                    "src": "3379:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_magic_abi",
+                                                                        "typeString": "abi"
+                                                                    }
+                                                                },
+                                                                "id": 4155,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "memberName": "encodeWithSelector",
+                                                                "nodeType": "MemberAccess",
+                                                                "src": "3379:22:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_abiencodewithselector_pure$_t_bytes4_$returns$_t_bytes_memory_ptr_$",
+                                                                    "typeString": "function (bytes4) pure returns (bytes memory)"
+                                                                }
+                                                            },
+                                                            "id": 4157,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "3379:34:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 4152,
+                                                            "name": "token",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4104,
+                                                            "src": "3368:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        "id": 4153,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "call",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "3368:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_barecall_payable$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                            "typeString": "function (bytes memory) payable returns (bool,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4158,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "3368:46:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                        "typeString": "tuple(bool,bytes memory)"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "3338:76:6"
+                                            },
+                                            {
+                                                "assignments": [4161],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 4161,
+                                                        "mutability": "mutable",
+                                                        "name": "totSup",
+                                                        "nameLocation": "3436:6:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 4202,
+                                                        "src": "3428:14:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 4160,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "3428:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 4169,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 4164,
+                                                            "name": "totSupData",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4151,
+                                                            "src": "3456:10:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "components": [
+                                                                {
+                                                                    "id": 4166,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                                    "src": "3469:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_type$_t_uint256_$",
+                                                                        "typeString": "type(uint256)"
+                                                                    },
+                                                                    "typeName": {
+                                                                        "id": 4165,
+                                                                        "name": "uint256",
+                                                                        "nodeType": "ElementaryTypeName",
+                                                                        "src": "3469:7:6",
+                                                                        "typeDescriptions": {}
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "id": 4167,
+                                                            "isConstant": false,
+                                                            "isInlineArray": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "TupleExpression",
+                                                            "src": "3468:9:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 4162,
+                                                            "name": "abi",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -1,
+                                                            "src": "3445:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_abi",
+                                                                "typeString": "abi"
+                                                            }
+                                                        },
+                                                        "id": 4163,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "memberName": "decode",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "3445:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_abidecode_pure$__$returns$__$",
+                                                            "typeString": "function () pure"
+                                                        }
+                                                    },
+                                                    "id": 4168,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "3445:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "3428:50:6"
+                                            },
+                                            {
+                                                "condition": {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    "id": 4172,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "id": 4170,
+                                                        "name": "give",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4108,
+                                                        "src": "3495:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "<",
+                                                    "rightExpression": {
+                                                        "id": 4171,
+                                                        "name": "prevBal",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4125,
+                                                        "src": "3502:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "3495:14:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "falseBody": {
+                                                    "id": 4188,
+                                                    "nodeType": "Block",
+                                                    "src": "3576:59:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "id": 4186,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "leftHandSide": {
+                                                                    "id": 4181,
+                                                                    "name": "totSup",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 4161,
+                                                                    "src": "3594:6:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "nodeType": "Assignment",
+                                                                "operator": "+=",
+                                                                "rightHandSide": {
+                                                                    "components": [
+                                                                        {
+                                                                            "commonType": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            },
+                                                                            "id": 4184,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftExpression": {
+                                                                                "id": 4182,
+                                                                                "name": "give",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4108,
+                                                                                "src": "3605:4:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "BinaryOperation",
+                                                                            "operator": "-",
+                                                                            "rightExpression": {
+                                                                                "id": 4183,
+                                                                                "name": "prevBal",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4125,
+                                                                                "src": "3612:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "src": "3605:14:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "id": 4185,
+                                                                    "isConstant": false,
+                                                                    "isInlineArray": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "TupleExpression",
+                                                                    "src": "3604:16:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "src": "3594:26:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "id": 4187,
+                                                            "nodeType": "ExpressionStatement",
+                                                            "src": "3594:26:6"
+                                                        }
+                                                    ]
+                                                },
+                                                "id": 4189,
+                                                "nodeType": "IfStatement",
+                                                "src": "3492:143:6",
+                                                "trueBody": {
+                                                    "id": 4180,
+                                                    "nodeType": "Block",
+                                                    "src": "3511:59:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "id": 4178,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "leftHandSide": {
+                                                                    "id": 4173,
+                                                                    "name": "totSup",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 4161,
+                                                                    "src": "3529:6:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "nodeType": "Assignment",
+                                                                "operator": "-=",
+                                                                "rightHandSide": {
+                                                                    "components": [
+                                                                        {
+                                                                            "commonType": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            },
+                                                                            "id": 4176,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftExpression": {
+                                                                                "id": 4174,
+                                                                                "name": "prevBal",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4125,
+                                                                                "src": "3540:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "BinaryOperation",
+                                                                            "operator": "-",
+                                                                            "rightExpression": {
+                                                                                "id": 4175,
+                                                                                "name": "give",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 4108,
+                                                                                "src": "3550:4:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "src": "3540:14:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "id": 4177,
+                                                                    "isConstant": false,
+                                                                    "isInlineArray": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "TupleExpression",
+                                                                    "src": "3539:16:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "src": "3529:26:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "id": 4179,
+                                                            "nodeType": "ExpressionStatement",
+                                                            "src": "3529:26:6"
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 4199,
+                                                            "name": "totSup",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4161,
+                                                            "src": "3752:6:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "30783138313630646464",
+                                                                    "id": 4196,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "3709:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    },
+                                                                    "value": "0x18160ddd"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_rational_404098525_by_1",
+                                                                        "typeString": "int_const 404098525"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 4193,
+                                                                            "name": "token",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 4104,
+                                                                            "src": "3681:5:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 4190,
+                                                                            "name": "stdstore",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 3831,
+                                                                            "src": "3648:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage",
+                                                                                "typeString": "struct StdStorage storage ref"
+                                                                            }
+                                                                        },
+                                                                        "id": 4192,
+                                                                        "isConstant": false,
+                                                                        "isLValue": true,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "target",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 5549,
+                                                                        "src": "3648:32:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_address_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                            "typeString": "function (struct StdStorage storage pointer,address) returns (struct StdStorage storage pointer)"
+                                                                        }
+                                                                    },
+                                                                    "id": 4194,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "3648:39:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                    }
+                                                                },
+                                                                "id": 4195,
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "memberName": "sig",
+                                                                "nodeType": "MemberAccess",
+                                                                "referencedDeclaration": 5569,
+                                                                "src": "3648:60:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes4_$returns$_t_struct$_StdStorage_$5033_storage_ptr_$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                                    "typeString": "function (struct StdStorage storage pointer,bytes4) returns (struct StdStorage storage pointer)"
+                                                                }
+                                                            },
+                                                            "id": 4197,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "3648:72:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        },
+                                                        "id": 4198,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "checked_write",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 5729,
+                                                        "src": "3648:103:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_uint256_$returns$__$bound_to$_t_struct$_StdStorage_$5033_storage_ptr_$",
+                                                            "typeString": "function (struct StdStorage storage pointer,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4200,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "3648:111:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4201,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "3648:111:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "functionSelector": "97754ae9",
+                        "id": 4205,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deal",
+                        "nameLocation": "2870:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4111,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4104,
+                                    "mutability": "mutable",
+                                    "name": "token",
+                                    "nameLocation": "2883:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2875:13:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4103,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2875:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4106,
+                                    "mutability": "mutable",
+                                    "name": "to",
+                                    "nameLocation": "2898:2:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2890:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4105,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2890:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4108,
+                                    "mutability": "mutable",
+                                    "name": "give",
+                                    "nameLocation": "2910:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2902:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4107,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2902:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4110,
+                                    "mutability": "mutable",
+                                    "name": "adjust",
+                                    "nameLocation": "2921:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4205,
+                                    "src": "2916:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4109,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2916:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2874:54:6"
+                        },
+                        "returnParameters": {
+                            "id": 4112,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2936:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "2861:915:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4226,
+                            "nodeType": "Block",
+                            "src": "4045:221:6",
+                            "statements": [
+                                {
+                                    "assignments": [4215],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4215,
+                                            "mutability": "mutable",
+                                            "name": "bytecode",
+                                            "nameLocation": "4068:8:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4226,
+                                            "src": "4055:21:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 4214,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "4055:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4224,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 4220,
+                                                        "name": "what",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 4207,
+                                                        "src": "4107:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_string_memory_ptr",
+                                                            "typeString": "string memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_string_memory_ptr",
+                                                            "typeString": "string memory"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 4218,
+                                                        "name": "vm",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 3828,
+                                                        "src": "4096:2:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_contract$_Vm_$6200",
+                                                            "typeString": "contract Vm"
+                                                        }
+                                                    },
+                                                    "id": 4219,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "getCode",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 6187,
+                                                    "src": "4096:10:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_external_nonpayable$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (string memory) external returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 4221,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "4096:16:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            },
+                                            {
+                                                "id": 4222,
+                                                "name": "args",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4209,
+                                                "src": "4114:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4216,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "4079:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 4217,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "encodePacked",
+                                            "nodeType": "MemberAccess",
+                                            "src": "4079:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function () pure returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 4223,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4079:40:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "4055:64:6"
+                                },
+                                {
+                                    "AST": {
+                                        "nodeType": "YulBlock",
+                                        "src": "4181:79:6",
+                                        "statements": [
+                                            {
+                                                "nodeType": "YulAssignment",
+                                                "src": "4195:55:6",
+                                                "value": {
+                                                    "arguments": [
+                                                        {
+                                                            "kind": "number",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "4210:1:6",
+                                                            "type": "",
+                                                            "value": "0"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4217:8:6"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "4227:4:6",
+                                                                    "type": "",
+                                                                    "value": "0x20"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "add",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4213:3:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4213:19:6"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4240:8:6"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "mload",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4234:5:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4234:15:6"
+                                                        }
+                                                    ],
+                                                    "functionName": {
+                                                        "name": "create",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4203:6:6"
+                                                    },
+                                                    "nodeType": "YulFunctionCall",
+                                                    "src": "4203:47:6"
+                                                },
+                                                "variableNames": [
+                                                    {
+                                                        "name": "addr",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4195:4:6"
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    },
+                                    "documentation": "@solidity memory-safe-assembly",
+                                    "evmVersion": "london",
+                                    "externalReferences": [
+                                        {
+                                            "declaration": 4212,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4195:4:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4215,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4217:8:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4215,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4240:8:6",
+                                            "valueSize": 1
+                                        }
+                                    ],
+                                    "id": 4225,
+                                    "nodeType": "InlineAssembly",
+                                    "src": "4172:88:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "29ce9dde",
+                        "id": 4227,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deployCode",
+                        "nameLocation": "3945:10:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4210,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4207,
+                                    "mutability": "mutable",
+                                    "name": "what",
+                                    "nameLocation": "3970:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4227,
+                                    "src": "3956:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4206,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3956:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4209,
+                                    "mutability": "mutable",
+                                    "name": "args",
+                                    "nameLocation": "3989:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4227,
+                                    "src": "3976:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4208,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3976:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "3955:39:6"
+                        },
+                        "returnParameters": {
+                            "id": 4213,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4212,
+                                    "mutability": "mutable",
+                                    "name": "addr",
+                                    "nameLocation": "4035:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4227,
+                                    "src": "4027:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4211,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4027:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4026:14:6"
+                        },
+                        "scope": 4935,
+                        "src": "3936:330:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4242,
+                            "nodeType": "Block",
+                            "src": "4362:197:6",
+                            "statements": [
+                                {
+                                    "assignments": [4235],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4235,
+                                            "mutability": "mutable",
+                                            "name": "bytecode",
+                                            "nameLocation": "4385:8:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4242,
+                                            "src": "4372:21:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 4234,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "4372:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4240,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 4238,
+                                                "name": "what",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4229,
+                                                "src": "4407:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 4236,
+                                                "name": "vm",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 3828,
+                                                "src": "4396:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 4237,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "getCode",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6187,
+                                            "src": "4396:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function (string memory) external returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 4239,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4396:16:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "4372:40:6"
+                                },
+                                {
+                                    "AST": {
+                                        "nodeType": "YulBlock",
+                                        "src": "4474:79:6",
+                                        "statements": [
+                                            {
+                                                "nodeType": "YulAssignment",
+                                                "src": "4488:55:6",
+                                                "value": {
+                                                    "arguments": [
+                                                        {
+                                                            "kind": "number",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "4503:1:6",
+                                                            "type": "",
+                                                            "value": "0"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4510:8:6"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "4520:4:6",
+                                                                    "type": "",
+                                                                    "value": "0x20"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "add",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4506:3:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4506:19:6"
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "name": "bytecode",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "4533:8:6"
+                                                                }
+                                                            ],
+                                                            "functionName": {
+                                                                "name": "mload",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "4527:5:6"
+                                                            },
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "4527:15:6"
+                                                        }
+                                                    ],
+                                                    "functionName": {
+                                                        "name": "create",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4496:6:6"
+                                                    },
+                                                    "nodeType": "YulFunctionCall",
+                                                    "src": "4496:47:6"
+                                                },
+                                                "variableNames": [
+                                                    {
+                                                        "name": "addr",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "4488:4:6"
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    },
+                                    "documentation": "@solidity memory-safe-assembly",
+                                    "evmVersion": "london",
+                                    "externalReferences": [
+                                        {
+                                            "declaration": 4232,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4488:4:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4235,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4510:8:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 4235,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "4533:8:6",
+                                            "valueSize": 1
+                                        }
+                                    ],
+                                    "id": 4241,
+                                    "nodeType": "InlineAssembly",
+                                    "src": "4465:88:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "9a8325a0",
+                        "id": 4243,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deployCode",
+                        "nameLocation": "4281:10:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4230,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4229,
+                                    "mutability": "mutable",
+                                    "name": "what",
+                                    "nameLocation": "4306:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4243,
+                                    "src": "4292:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4228,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4292:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4291:20:6"
+                        },
+                        "returnParameters": {
+                            "id": 4233,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4232,
+                                    "mutability": "mutable",
+                                    "name": "addr",
+                                    "nameLocation": "4352:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4243,
+                                    "src": "4344:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 4231,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4344:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4343:14:6"
+                        },
+                        "scope": 4935,
+                        "src": "4272:287:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 4253,
+                            "nodeType": "Block",
+                            "src": "4827:34:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4250,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "UnaryOperation",
+                                                "operator": "!",
+                                                "prefix": true,
+                                                "src": "4848:5:6",
+                                                "subExpression": {
+                                                    "id": 4249,
+                                                    "name": "data",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4245,
+                                                    "src": "4849:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            ],
+                                            "id": 4248,
+                                            "name": "assertTrue",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                2289, 2310
+                                            ],
+                                            "referencedDeclaration": 2289,
+                                            "src": "4837:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_bool_$returns$__$",
+                                                "typeString": "function (bool)"
+                                            }
+                                        },
+                                        "id": 4251,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4837:17:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4252,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "4837:17:6"
+                                }
+                            ]
+                        },
+                        "id": 4254,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertFalse",
+                        "nameLocation": "4787:11:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4246,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4245,
+                                    "mutability": "mutable",
+                                    "name": "data",
+                                    "nameLocation": "4804:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4254,
+                                    "src": "4799:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4244,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4799:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4798:11:6"
+                        },
+                        "returnParameters": {
+                            "id": 4247,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "4827:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "4778:83:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4267,
+                            "nodeType": "Block",
+                            "src": "4935:39:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 4263,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "UnaryOperation",
+                                                "operator": "!",
+                                                "prefix": true,
+                                                "src": "4956:5:6",
+                                                "subExpression": {
+                                                    "id": 4262,
+                                                    "name": "data",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4256,
+                                                    "src": "4957:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "id": 4264,
+                                                "name": "err",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4258,
+                                                "src": "4963:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                    "typeString": "string memory"
+                                                }
+                                            ],
+                                            "id": 4261,
+                                            "name": "assertTrue",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                2289, 2310
+                                            ],
+                                            "referencedDeclaration": 2310,
+                                            "src": "4945:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory)"
+                                            }
+                                        },
+                                        "id": 4265,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "4945:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 4266,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "4945:22:6"
+                                }
+                            ]
+                        },
+                        "id": 4268,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertFalse",
+                        "nameLocation": "4876:11:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4259,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4256,
+                                    "mutability": "mutable",
+                                    "name": "data",
+                                    "nameLocation": "4893:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4268,
+                                    "src": "4888:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4255,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4888:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4258,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "4913:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4268,
+                                    "src": "4899:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4257,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4899:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4887:30:6"
+                        },
+                        "returnParameters": {
+                            "id": 4260,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "4935:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "4867:107:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4303,
+                            "nodeType": "Block",
+                            "src": "5023:283:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        },
+                                        "id": 4277,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4275,
+                                            "name": "a",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4270,
+                                            "src": "5037:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "id": 4276,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4272,
+                                            "src": "5042:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "src": "5037:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4302,
+                                    "nodeType": "IfStatement",
+                                    "src": "5033:267:6",
+                                    "trueBody": {
+                                        "id": 4301,
+                                        "nodeType": "Block",
+                                        "src": "5045:255:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061203d3d2062206e6f7420736174697366696564205b626f6f6c5d",
+                                                            "id": 4279,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5084:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_8b48ec9ac4dc7123ad32509232067c63ebae61bff18d5e06bf4dea2a25240ed2",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bool]\""
+                                                            },
+                                                            "value": "Error: a == b not satisfied [bool]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_8b48ec9ac4dc7123ad32509232067c63ebae61bff18d5e06bf4dea2a25240ed2",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bool]\""
+                                                            }
+                                                        ],
+                                                        "id": 4278,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "5064:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4280,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5064:57:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4281,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5059:62:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4283,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5160:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4284,
+                                                                "name": "b",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4272,
+                                                                "src": "5174:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4286,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5187:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4287,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5174:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4285,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5178:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4282,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5140:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4288,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5140:55:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4289,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5135:60:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4291,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5234:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4292,
+                                                                "name": "a",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4270,
+                                                                "src": "5248:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4294,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5261:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4295,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5248:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4293,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5252:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4290,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5214:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4296,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5214:55:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4297,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5209:60:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4298,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "5283:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4299,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5283:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4300,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5283:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4304,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "4989:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4273,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4270,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5003:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4304,
+                                    "src": "4998:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4269,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "4998:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4272,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "5011:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4304,
+                                    "src": "5006:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4271,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5006:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "4997:16:6"
+                        },
+                        "returnParameters": {
+                            "id": 4274,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "5023:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "4980:326:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4342,
+                            "nodeType": "Block",
+                            "src": "5374:250:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        },
+                                        "id": 4315,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4313,
+                                            "name": "a",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4306,
+                                            "src": "5388:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "id": 4314,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4308,
+                                            "src": "5393:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "src": "5388:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4341,
+                                    "nodeType": "IfStatement",
+                                    "src": "5384:234:6",
+                                    "trueBody": {
+                                        "id": 4340,
+                                        "nodeType": "Block",
+                                        "src": "5396:222:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4317,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5432:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4318,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4310,
+                                                            "src": "5441:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4316,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5415:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4319,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5415:30:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4320,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5410:35:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4322,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5481:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4323,
+                                                                "name": "b",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4308,
+                                                                "src": "5495:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4325,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5508:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4326,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5495:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4324,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5499:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4321,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5464:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4327,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5464:52:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4328,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5459:57:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4330,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5552:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "condition": {
+                                                                "id": 4331,
+                                                                "name": "a",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 4306,
+                                                                "src": "5566:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                }
+                                                            },
+                                                            "falseExpression": {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 4333,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5579:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_ba9154e0baa69c78e0ca563b867df81bae9d177c4ea1452c35c84386a70f0f7a",
+                                                                    "typeString": "literal_string \"false\""
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            "id": 4334,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Conditional",
+                                                            "src": "5566:20:6",
+                                                            "trueExpression": {
+                                                                "hexValue": "74727565",
+                                                                "id": 4332,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "5570:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034",
+                                                                    "typeString": "literal_string \"true\""
+                                                                },
+                                                                "value": "true"
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4329,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "5535:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4335,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5535:52:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4336,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5530:57:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4337,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "5601:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4338,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5601:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4339,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5601:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4343,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "5321:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4311,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4306,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5335:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4343,
+                                    "src": "5330:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4305,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5330:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4308,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "5343:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4343,
+                                    "src": "5338:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 4307,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5338:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4310,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "5360:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4343,
+                                    "src": "5346:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4309,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5346:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "5329:35:6"
+                        },
+                        "returnParameters": {
+                            "id": 4312,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "5374:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "5312:312:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4376,
+                            "nodeType": "Block",
+                            "src": "5697:256:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        },
+                                        "id": 4356,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4351,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4345,
+                                                    "src": "5721:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4350,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "5711:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4352,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "5711:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4354,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4347,
+                                                    "src": "5737:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4353,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "5727:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4355,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "5727:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "src": "5711:28:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4375,
+                                    "nodeType": "IfStatement",
+                                    "src": "5707:240:6",
+                                    "trueBody": {
+                                        "id": 4374,
+                                        "nodeType": "Block",
+                                        "src": "5741:206:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061203d3d2062206e6f7420736174697366696564205b62797465735d",
+                                                            "id": 4358,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5776:37:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_9bb7b728691fe2872efdd27bd07c4a95b3586c3b7ec3afa731a7c21a76e39cfc",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bytes]\""
+                                                            },
+                                                            "value": "Error: a == b not satisfied [bytes]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_9bb7b728691fe2872efdd27bd07c4a95b3586c3b7ec3afa731a7c21a76e39cfc",
+                                                                "typeString": "literal_string \"Error: a == b not satisfied [bytes]\""
+                                                            }
+                                                        ],
+                                                        "id": 4357,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "5760:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4359,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5760:54:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4360,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5755:59:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4362,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5849:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4363,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4347,
+                                                            "src": "5863:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4361,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "5833:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4364,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5833:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4365,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5828:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4367,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "5900:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4368,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4345,
+                                                            "src": "5914:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4366,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "5884:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4369,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5884:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4370,
+                                                "nodeType": "EmitStatement",
+                                                "src": "5879:37:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4371,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "5930:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4372,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "5930:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4373,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "5930:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4377,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "5639:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4348,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4345,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5661:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4377,
+                                    "src": "5648:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4344,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5648:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4347,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "5677:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4377,
+                                    "src": "5664:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4346,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5664:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "5647:32:6"
+                        },
+                        "returnParameters": {
+                            "id": 4349,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "5697:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "5630:323:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4413,
+                            "nodeType": "Block",
+                            "src": "6045:243:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        },
+                                        "id": 4392,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4387,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4379,
+                                                    "src": "6069:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4386,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "6059:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4388,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "6059:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4390,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4381,
+                                                    "src": "6085:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 4389,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "6075:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 4391,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "6075:12:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "src": "6059:28:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4412,
+                                    "nodeType": "IfStatement",
+                                    "src": "6055:227:6",
+                                    "trueBody": {
+                                        "id": 4411,
+                                        "nodeType": "Block",
+                                        "src": "6089:193:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4394,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6128:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4395,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4383,
+                                                            "src": "6137:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4393,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "6108:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4396,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6108:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4397,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6103:38:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4399,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6180:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4400,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4381,
+                                                            "src": "6194:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4398,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "6160:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4401,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6160:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4402,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6155:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4404,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6235:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4405,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4379,
+                                                            "src": "6249:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 4403,
+                                                        "name": "log_named_bytes",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2099,
+                                                        "src": "6215:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_bytes_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 4406,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6215:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4407,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6210:41:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4408,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "6265:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4409,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6265:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4410,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "6265:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4414,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertEq",
+                        "nameLocation": "5968:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4384,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4379,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "5990:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4414,
+                                    "src": "5977:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4378,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5977:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4381,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "6006:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4414,
+                                    "src": "5993:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 4380,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "5993:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4383,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "6023:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4414,
+                                    "src": "6009:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4382,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6009:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "5976:51:6"
+                        },
+                        "returnParameters": {
+                            "id": 4385,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "6045:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "5959:329:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4468,
+                            "nodeType": "Block",
+                            "src": "6408:404:6",
+                            "statements": [
+                                {
+                                    "assignments": [4424],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4424,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "6426:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4468,
+                                            "src": "6418:13:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4423,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "6418:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4435,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4427,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4425,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4416,
+                                                "src": "6434:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4426,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4418,
+                                                "src": "6438:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6434:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4433,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4431,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4418,
+                                                "src": "6450:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4432,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4416,
+                                                "src": "6454:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6450:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 4434,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "6434:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4430,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4428,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4416,
+                                                "src": "6442:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4429,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4418,
+                                                "src": "6446:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6442:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "6418:37:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4438,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4436,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4424,
+                                            "src": "6470:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4437,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4420,
+                                            "src": "6478:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "6470:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4467,
+                                    "nodeType": "IfStatement",
+                                    "src": "6466:340:6",
+                                    "trueBody": {
+                                        "id": 4466,
+                                        "nodeType": "Block",
+                                        "src": "6488:318:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b75696e745d",
+                                                            "id": 4440,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6523:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [uint]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            }
+                                                        ],
+                                                        "id": 4439,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "6507:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4441,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6507:53:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4442,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6502:58:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4444,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6595:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4445,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4418,
+                                                            "src": "6609:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4443,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6579:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4446,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6579:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4447,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6574:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4449,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6646:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4450,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4416,
+                                                            "src": "6660:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4448,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6630:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4451,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6630:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4452,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6625:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4454,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6697:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4455,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4420,
+                                                            "src": "6711:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4453,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6681:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4456,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6681:39:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4457,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6676:44:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4459,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "6755:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4460,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4424,
+                                                            "src": "6769:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4458,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "6739:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4461,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6739:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4462,
+                                                "nodeType": "EmitStatement",
+                                                "src": "6734:41:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4463,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "6789:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4464,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "6789:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4465,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "6789:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4469,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "6303:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4421,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4416,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "6338:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4469,
+                                    "src": "6330:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4415,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6330:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4418,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "6357:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4469,
+                                    "src": "6349:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4417,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6349:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4420,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "6376:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4469,
+                                    "src": "6368:16:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4419,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6368:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "6320:70:6"
+                        },
+                        "returnParameters": {
+                            "id": 4422,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "6408:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "6294:518:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4526,
+                            "nodeType": "Block",
+                            "src": "6959:400:6",
+                            "statements": [
+                                {
+                                    "assignments": [4481],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4481,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "6977:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4526,
+                                            "src": "6969:13:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4480,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "6969:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4492,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4484,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4482,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4471,
+                                                "src": "6985:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4483,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4473,
+                                                "src": "6989:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6985:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4490,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4488,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4473,
+                                                "src": "7001:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4489,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4471,
+                                                "src": "7005:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "7001:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 4491,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "6985:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 4487,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4485,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4471,
+                                                "src": "6993:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4486,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4473,
+                                                "src": "6997:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "src": "6993:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "6969:37:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4495,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4493,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4481,
+                                            "src": "7021:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4494,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4475,
+                                            "src": "7029:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "7021:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4525,
+                                    "nodeType": "IfStatement",
+                                    "src": "7017:336:6",
+                                    "trueBody": {
+                                        "id": 4524,
+                                        "nodeType": "Block",
+                                        "src": "7039:314:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4497,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7078:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4498,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4477,
+                                                            "src": "7087:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4496,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "7058:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4499,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7058:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4500,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7053:38:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4502,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7130:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4503,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4473,
+                                                            "src": "7144:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4501,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7110:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4504,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7110:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4505,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7105:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4507,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7185:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4508,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4471,
+                                                            "src": "7199:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4506,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7165:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4509,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7165:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4510,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7160:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4512,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7240:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4513,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4475,
+                                                            "src": "7254:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4511,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7220:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4514,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7220:43:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4515,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7215:48:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4517,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7302:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4518,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4481,
+                                                            "src": "7316:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4516,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "7282:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4519,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7282:40:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4520,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7277:45:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4521,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "7336:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4522,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7336:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4523,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "7336:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4527,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "6827:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4478,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4471,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "6862:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6854:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4470,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6854:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4473,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "6881:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6873:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4472,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6873:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4475,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "6900:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6892:16:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4474,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6892:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4477,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "6932:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4527,
+                                    "src": "6918:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4476,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "6918:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "6844:97:6"
+                        },
+                        "returnParameters": {
+                            "id": 4479,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "6959:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "6818:541:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4581,
+                            "nodeType": "Block",
+                            "src": "7476:402:6",
+                            "statements": [
+                                {
+                                    "assignments": [4537],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4537,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "7493:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4581,
+                                            "src": "7486:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4536,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "7486:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4548,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4540,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4538,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4529,
+                                                "src": "7501:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4539,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4531,
+                                                "src": "7505:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "7501:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4546,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4544,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4531,
+                                                "src": "7517:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4545,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4529,
+                                                "src": "7521:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "7517:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "id": 4547,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "7501:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4543,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4541,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4529,
+                                                "src": "7509:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4542,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4531,
+                                                "src": "7513:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "7509:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "7486:36:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4551,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4549,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4537,
+                                            "src": "7537:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4550,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4533,
+                                            "src": "7545:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "7537:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4580,
+                                    "nodeType": "IfStatement",
+                                    "src": "7533:339:6",
+                                    "trueBody": {
+                                        "id": 4579,
+                                        "nodeType": "Block",
+                                        "src": "7555:317:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b696e745d",
+                                                            "id": 4553,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7590:35:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_11d61c8cdd58caffa5994831eb66eb6db7a7b4d13b2c9d187ffbe992d75f810d",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [int]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [int]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_11d61c8cdd58caffa5994831eb66eb6db7a7b4d13b2c9d187ffbe992d75f810d",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [int]\""
+                                                            }
+                                                        ],
+                                                        "id": 4552,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "7574:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4554,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7574:52:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4555,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7569:57:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4557,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7661:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4558,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4531,
+                                                            "src": "7675:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4556,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7645:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4559,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7645:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4560,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7640:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4562,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7712:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4563,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4529,
+                                                            "src": "7726:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4561,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7696:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4564,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7696:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4565,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7691:37:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4567,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7763:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4568,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4533,
+                                                            "src": "7777:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4566,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7747:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4569,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7747:39:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4570,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7742:44:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4572,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "7821:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4573,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4537,
+                                                            "src": "7835:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4571,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "7805:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4574,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7805:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4575,
+                                                "nodeType": "EmitStatement",
+                                                "src": "7800:41:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4576,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "7855:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4577,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "7855:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4578,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "7855:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4582,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "7374:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4534,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4529,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "7408:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4582,
+                                    "src": "7401:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4528,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7401:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4531,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "7426:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4582,
+                                    "src": "7419:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4530,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7419:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4533,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "7444:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4582,
+                                    "src": "7437:15:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4532,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7437:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "7391:67:6"
+                        },
+                        "returnParameters": {
+                            "id": 4535,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "7476:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "7365:513:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4639,
+                            "nodeType": "Block",
+                            "src": "8022:399:6",
+                            "statements": [
+                                {
+                                    "assignments": [4594],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4594,
+                                            "mutability": "mutable",
+                                            "name": "delta",
+                                            "nameLocation": "8039:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4639,
+                                            "src": "8032:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4593,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "8032:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4605,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4597,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4595,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4584,
+                                                "src": "8047:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "id": 4596,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4586,
+                                                "src": "8051:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "8047:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4603,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4601,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4586,
+                                                "src": "8063:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4602,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4584,
+                                                "src": "8067:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "8063:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "id": 4604,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "8047:21:6",
+                                        "trueExpression": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "id": 4600,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "id": 4598,
+                                                "name": "a",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4584,
+                                                "src": "8055:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": "-",
+                                            "rightExpression": {
+                                                "id": 4599,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 4586,
+                                                "src": "8059:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "src": "8055:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "8032:36:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4608,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4606,
+                                            "name": "delta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4594,
+                                            "src": "8083:5:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4607,
+                                            "name": "maxDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4588,
+                                            "src": "8091:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "8083:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4638,
+                                    "nodeType": "IfStatement",
+                                    "src": "8079:336:6",
+                                    "trueBody": {
+                                        "id": 4637,
+                                        "nodeType": "Block",
+                                        "src": "8101:314:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4610,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8140:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4611,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4590,
+                                                            "src": "8149:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4609,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "8120:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4612,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8120:33:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4613,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8115:38:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20204578706563746564",
+                                                            "id": 4615,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8192:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            "value": "  Expected"
+                                                        },
+                                                        {
+                                                            "id": 4616,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4586,
+                                                            "src": "8206:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_42fa07d7c51ce5de92a0fc65dbf7e7800814fd01c258dc50e84d5be59184bf0b",
+                                                                "typeString": "literal_string \"  Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4614,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8172:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4617,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8172:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4618,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8167:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202041637475616c",
+                                                            "id": 4620,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8247:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            "value": "    Actual"
+                                                        },
+                                                        {
+                                                            "id": 4621,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4584,
+                                                            "src": "8261:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_d7896f3f645b3ba89da46bf231a5df16e525e587a84bc9b284dfb39958fb219b",
+                                                                "typeString": "literal_string \"    Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4619,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8227:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4622,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8227:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4623,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8222:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d61782044656c7461",
+                                                            "id": 4625,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8302:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            "value": " Max Delta"
+                                                        },
+                                                        {
+                                                            "id": 4626,
+                                                            "name": "maxDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4588,
+                                                            "src": "8316:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_cd2884c74a25327f5cafe8471ed73da28ba1991b65dde72feb1cd4f78f5dc2a5",
+                                                                "typeString": "literal_string \" Max Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4624,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8282:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4627,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8282:43:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4628,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8277:48:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020202044656c7461",
+                                                            "id": 4630,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8364:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            "value": "     Delta"
+                                                        },
+                                                        {
+                                                            "id": 4631,
+                                                            "name": "delta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4594,
+                                                            "src": "8378:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_39d8d5e74991bbc141eb1ca770e60e69523d5c43706b72685708d217b293c55f",
+                                                                "typeString": "literal_string \"     Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4629,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "8344:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4632,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8344:40:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4633,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8339:45:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4634,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "8398:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4635,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8398:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4636,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "8398:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4640,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqAbs",
+                        "nameLocation": "7893:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4591,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4584,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "7927:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7920:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4583,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7920:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4586,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "7945:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7938:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4585,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7938:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4588,
+                                    "mutability": "mutable",
+                                    "name": "maxDelta",
+                                    "nameLocation": "7963:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7956:15:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4587,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7956:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4590,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "7995:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4640,
+                                    "src": "7981:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4589,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "7981:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "7910:94:6"
+                        },
+                        "returnParameters": {
+                            "id": 4592,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "8022:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "7884:537:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4711,
+                            "nodeType": "Block",
+                            "src": "8604:599:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4651,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4649,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4644,
+                                            "src": "8618:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4650,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "8623:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "8618:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4657,
+                                    "nodeType": "IfStatement",
+                                    "src": "8614:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4653,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4642,
+                                                    "src": "8642:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4654,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4644,
+                                                    "src": "8645:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "id": 4652,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2534,
+                                                "src": "8633:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_uint256_$_t_uint256_$returns$__$",
+                                                    "typeString": "function (uint256,uint256)"
+                                                }
+                                            },
+                                            "id": 4655,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "8633:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4648,
+                                        "id": 4656,
+                                        "nodeType": "Return",
+                                        "src": "8626:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4659],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4659,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "8711:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4711,
+                                            "src": "8703:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4658,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "8703:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4676,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4675,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    "id": 4672,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4662,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4660,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4642,
+                                                                        "src": "8728:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4661,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4644,
+                                                                        "src": "8732:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "8728:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4668,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4666,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4644,
+                                                                        "src": "8744:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4667,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4642,
+                                                                        "src": "8748:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "8744:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "id": 4669,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "8728:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4665,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4663,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4642,
+                                                                        "src": "8736:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4664,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4644,
+                                                                        "src": "8740:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "8736:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4670,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "8727:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4671,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "8753:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "8727:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4673,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "8726:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4674,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4644,
+                                            "src": "8761:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "8726:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "8703:59:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4679,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4677,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4659,
+                                            "src": "8777:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4678,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4646,
+                                            "src": "8792:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "8777:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4710,
+                                    "nodeType": "IfStatement",
+                                    "src": "8773:424:6",
+                                    "trueBody": {
+                                        "id": 4709,
+                                        "nodeType": "Block",
+                                        "src": "8809:388:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b75696e745d",
+                                                            "id": 4681,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8852:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [uint]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            }
+                                                        ],
+                                                        "id": 4680,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "8828:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4682,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8828:61:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4683,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8823:66:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4685,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8932:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4686,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4644,
+                                                            "src": "8948:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4684,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "8908:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4687,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8908:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4688,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8903:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4690,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "8993:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4691,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4642,
+                                                            "src": "9009:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4689,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "8969:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4692,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "8969:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4693,
+                                                "nodeType": "EmitStatement",
+                                                "src": "8964:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4695,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9054:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4696,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4646,
+                                                            "src": "9070:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4697,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9087:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4694,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9030:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4698,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9030:60:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4699,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9025:65:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4701,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9133:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4702,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4659,
+                                                            "src": "9149:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4703,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9163:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4700,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9109:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4704,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9109:57:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4705,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9104:62:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4706,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "9180:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4707,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9180:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4708,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "9180:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4712,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "8436:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4647,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4642,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "8471:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4712,
+                                    "src": "8463:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4641,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "8463:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4644,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "8490:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4712,
+                                    "src": "8482:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4643,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "8482:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4646,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "8509:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4712,
+                                    "src": "8501:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4645,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "8501:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "8453:133:6"
+                        },
+                        "returnParameters": {
+                            "id": 4648,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "8604:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "8427:776:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4786,
+                            "nodeType": "Block",
+                            "src": "9413:575:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4725,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4723,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4716,
+                                            "src": "9427:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4724,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "9432:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "9427:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4731,
+                                    "nodeType": "IfStatement",
+                                    "src": "9423:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4727,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4714,
+                                                    "src": "9451:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4728,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4716,
+                                                    "src": "9454:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "id": 4726,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2534,
+                                                "src": "9442:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_uint256_$_t_uint256_$returns$__$",
+                                                    "typeString": "function (uint256,uint256)"
+                                                }
+                                            },
+                                            "id": 4729,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "9442:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4722,
+                                        "id": 4730,
+                                        "nodeType": "Return",
+                                        "src": "9435:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4733],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4733,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "9520:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4786,
+                                            "src": "9512:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 4732,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "9512:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4750,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4749,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    },
+                                                    "id": 4746,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4736,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4734,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4714,
+                                                                        "src": "9537:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4735,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4716,
+                                                                        "src": "9541:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "9537:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4742,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4740,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4716,
+                                                                        "src": "9553:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4741,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4714,
+                                                                        "src": "9557:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "9553:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "id": 4743,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "9537:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 4739,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4737,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4714,
+                                                                        "src": "9545:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4738,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4716,
+                                                                        "src": "9549:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "src": "9545:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4744,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "9536:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4745,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "9562:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "9536:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4747,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "9535:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4748,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4716,
+                                            "src": "9570:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "9535:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "9512:59:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 4753,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4751,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4733,
+                                            "src": "9586:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4752,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4718,
+                                            "src": "9601:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "9586:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4785,
+                                    "nodeType": "IfStatement",
+                                    "src": "9582:400:6",
+                                    "trueBody": {
+                                        "id": 4784,
+                                        "nodeType": "Block",
+                                        "src": "9618:364:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4755,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9661:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4756,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4720,
+                                                            "src": "9670:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4754,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "9637:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4757,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9637:37:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4758,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9632:42:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4760,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9717:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4761,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4716,
+                                                            "src": "9733:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4759,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "9693:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4762,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9693:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4763,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9688:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4765,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9778:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4766,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4714,
+                                                            "src": "9794:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 4764,
+                                                        "name": "log_named_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2093,
+                                                        "src": "9754:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4767,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9754:42:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4768,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9749:47:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4770,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9839:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4771,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4718,
+                                                            "src": "9855:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4772,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9872:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4769,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9815:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4773,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9815:60:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4774,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9810:65:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4776,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9918:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4777,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4733,
+                                                            "src": "9934:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4778,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "9948:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4775,
+                                                        "name": "log_named_decimal_uint",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2081,
+                                                        "src": "9894:22:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_uint256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,uint256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4779,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9894:57:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4780,
+                                                "nodeType": "EmitStatement",
+                                                "src": "9889:62:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4781,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "9965:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4782,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "9965:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4783,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "9965:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4787,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "9218:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4721,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4714,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "9253:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9245:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4713,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9245:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4716,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "9272:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9264:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4715,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9264:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4718,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "9291:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9283:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 4717,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9283:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4720,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "9386:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4787,
+                                    "src": "9372:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4719,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "9372:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "9235:160:6"
+                        },
+                        "returnParameters": {
+                            "id": 4722,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "9413:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "9209:779:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4858,
+                            "nodeType": "Block",
+                            "src": "10168:593:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4798,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4796,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4791,
+                                            "src": "10182:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4797,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "10187:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "10182:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4804,
+                                    "nodeType": "IfStatement",
+                                    "src": "10178:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4800,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4789,
+                                                    "src": "10206:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4801,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4791,
+                                                    "src": "10209:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                ],
+                                                "id": 4799,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2479,
+                                                "src": "10197:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_int256_$_t_int256_$returns$__$",
+                                                    "typeString": "function (int256,int256)"
+                                                }
+                                            },
+                                            "id": 4802,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "10197:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4795,
+                                        "id": 4803,
+                                        "nodeType": "Return",
+                                        "src": "10190:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4806],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4806,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "10274:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4858,
+                                            "src": "10267:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4805,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "10267:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4823,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4822,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    "id": 4819,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4809,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4807,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4789,
+                                                                        "src": "10291:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4808,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4791,
+                                                                        "src": "10295:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "10291:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4815,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4813,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4791,
+                                                                        "src": "10307:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4814,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4789,
+                                                                        "src": "10311:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "10307:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "id": 4816,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "10291:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4812,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4810,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4789,
+                                                                        "src": "10299:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4811,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4791,
+                                                                        "src": "10303:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "10299:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_int256",
+                                                                    "typeString": "int256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4817,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "10290:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_int256",
+                                                            "typeString": "int256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4818,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "10316:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "10290:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4820,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "10289:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4821,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4791,
+                                            "src": "10324:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "10289:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "10267:58:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4826,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4824,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4806,
+                                            "src": "10340:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4825,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4793,
+                                            "src": "10355:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "10340:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4857,
+                                    "nodeType": "IfStatement",
+                                    "src": "10336:419:6",
+                                    "trueBody": {
+                                        "id": 4856,
+                                        "nodeType": "Block",
+                                        "src": "10372:383:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f723a2061207e3d2062206e6f7420736174697366696564205b75696e745d",
+                                                            "id": 4828,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10414:36:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            },
+                                                            "value": "Error: a ~= b not satisfied [uint]"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_b3cfa1421f120a399b6064fcc8d5188a4e28bcc717972b37d8e8a5e5cc07c7fe",
+                                                                "typeString": "literal_string \"Error: a ~= b not satisfied [uint]\""
+                                                            }
+                                                        ],
+                                                        "id": 4827,
+                                                        "name": "log",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2025,
+                                                        "src": "10391:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4829,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10391:60:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4830,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10386:65:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4832,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10493:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4833,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4791,
+                                                            "src": "10509:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4831,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "10470:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4834,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10470:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4835,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10465:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4837,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10553:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4838,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4789,
+                                                            "src": "10569:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4836,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "10530:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4839,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10530:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4840,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10525:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4842,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10613:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4843,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4793,
+                                                            "src": "10629:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4844,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10646:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4841,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "10590:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4845,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10590:59:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4846,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10585:64:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4848,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10691:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4849,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4806,
+                                                            "src": "10707:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4850,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "10721:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4847,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "10668:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4851,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10668:56:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4852,
+                                                "nodeType": "EmitStatement",
+                                                "src": "10663:61:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4853,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "10738:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4854,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "10738:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4855,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "10738:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4859,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "10003:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4794,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4789,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "10037:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4859,
+                                    "src": "10030:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4788,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10030:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4791,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "10055:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4859,
+                                    "src": "10048:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4790,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10048:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4793,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "10073:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4859,
+                                    "src": "10066:22:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4792,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10066:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "10020:130:6"
+                        },
+                        "returnParameters": {
+                            "id": 4795,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "10168:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "9994:767:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 4933,
+                            "nodeType": "Block",
+                            "src": "10968:569:6",
+                            "statements": [
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4872,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4870,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4863,
+                                            "src": "10982:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "30",
+                                            "id": 4871,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "10987:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "src": "10982:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4878,
+                                    "nodeType": "IfStatement",
+                                    "src": "10978:33:6",
+                                    "trueBody": {
+                                        "expression": {
+                                            "arguments": [
+                                                {
+                                                    "id": 4874,
+                                                    "name": "a",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4861,
+                                                    "src": "11006:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                },
+                                                {
+                                                    "id": 4875,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 4863,
+                                                    "src": "11009:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                ],
+                                                "id": 4873,
+                                                "name": "assertEq",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [
+                                                    4304, 4343, 4377, 4414,
+                                                    2340, 2365, 2395, 2420,
+                                                    2479, 2504, 2534, 2559,
+                                                    3659, 3694
+                                                ],
+                                                "referencedDeclaration": 2479,
+                                                "src": "10997:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_nonpayable$_t_int256_$_t_int256_$returns$__$",
+                                                    "typeString": "function (int256,int256)"
+                                                }
+                                            },
+                                            "id": 4876,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "10997:14:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_tuple$__$",
+                                                "typeString": "tuple()"
+                                            }
+                                        },
+                                        "functionReturnParameters": 4869,
+                                        "id": 4877,
+                                        "nodeType": "Return",
+                                        "src": "10990:21:6"
+                                    }
+                                },
+                                {
+                                    "assignments": [4880],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 4880,
+                                            "mutability": "mutable",
+                                            "name": "percentDelta",
+                                            "nameLocation": "11074:12:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 4933,
+                                            "src": "11067:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            },
+                                            "typeName": {
+                                                "id": 4879,
+                                                "name": "int256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "11067:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_int256",
+                                                    "typeString": "int256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 4897,
+                                    "initialValue": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4896,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "components": [
+                                                {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    },
+                                                    "id": 4893,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "components": [
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4883,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4881,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4861,
+                                                                        "src": "11091:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": ">",
+                                                                    "rightExpression": {
+                                                                        "id": 4882,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4863,
+                                                                        "src": "11095:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "11091:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "falseExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4889,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4887,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4863,
+                                                                        "src": "11107:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4888,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4861,
+                                                                        "src": "11111:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "11107:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "id": 4890,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Conditional",
+                                                                "src": "11091:21:6",
+                                                                "trueExpression": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    },
+                                                                    "id": 4886,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 4884,
+                                                                        "name": "a",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4861,
+                                                                        "src": "11099:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "-",
+                                                                    "rightExpression": {
+                                                                        "id": 4885,
+                                                                        "name": "b",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 4863,
+                                                                        "src": "11103:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_int256",
+                                                                            "typeString": "int256"
+                                                                        }
+                                                                    },
+                                                                    "src": "11099:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_int256",
+                                                                        "typeString": "int256"
+                                                                    }
+                                                                },
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_int256",
+                                                                    "typeString": "int256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "id": 4891,
+                                                        "isConstant": false,
+                                                        "isInlineArray": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "TupleExpression",
+                                                        "src": "11090:23:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_int256",
+                                                            "typeString": "int256"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "*",
+                                                    "rightExpression": {
+                                                        "hexValue": "31653138",
+                                                        "id": 4892,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "number",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "11116:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_rational_1000000000000000000_by_1",
+                                                            "typeString": "int_const 1000000000000000000"
+                                                        },
+                                                        "value": "1e18"
+                                                    },
+                                                    "src": "11090:30:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_int256",
+                                                        "typeString": "int256"
+                                                    }
+                                                }
+                                            ],
+                                            "id": 4894,
+                                            "isConstant": false,
+                                            "isInlineArray": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "TupleExpression",
+                                            "src": "11089:32:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "/",
+                                        "rightExpression": {
+                                            "id": 4895,
+                                            "name": "b",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4863,
+                                            "src": "11124:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "11089:36:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "11067:58:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        },
+                                        "id": 4900,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 4898,
+                                            "name": "percentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4880,
+                                            "src": "11140:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": ">",
+                                        "rightExpression": {
+                                            "id": 4899,
+                                            "name": "maxPercentDelta",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 4865,
+                                            "src": "11155:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_int256",
+                                                "typeString": "int256"
+                                            }
+                                        },
+                                        "src": "11140:30:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 4932,
+                                    "nodeType": "IfStatement",
+                                    "src": "11136:395:6",
+                                    "trueBody": {
+                                        "id": 4931,
+                                        "nodeType": "Block",
+                                        "src": "11172:359:6",
+                                        "statements": [
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "4572726f72",
+                                                            "id": 4902,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11214:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            "value": "Error"
+                                                        },
+                                                        {
+                                                            "id": 4903,
+                                                            "name": "err",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4867,
+                                                            "src": "11223:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_e342daa49723ff3485f4ff5f755a17b8bc9c3c33bbd312ceee37c94eebfe45c1",
+                                                                "typeString": "literal_string \"Error\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_string_memory_ptr",
+                                                                "typeString": "string memory"
+                                                            }
+                                                        ],
+                                                        "id": 4901,
+                                                        "name": "log_named_string",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2105,
+                                                        "src": "11191:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (string memory,string memory)"
+                                                        }
+                                                    },
+                                                    "id": 4904,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11191:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4905,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11186:41:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "202020204578706563746564",
+                                                            "id": 4907,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11269:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            "value": "    Expected"
+                                                        },
+                                                        {
+                                                            "id": 4908,
+                                                            "name": "b",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4863,
+                                                            "src": "11285:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0e33bb6058f2c6cccd03674115e231a9d0cfe482a7efa638b81035808613e7d3",
+                                                                "typeString": "literal_string \"    Expected\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4906,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "11246:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4909,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11246:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4910,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11241:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "20202020202041637475616c",
+                                                            "id": 4912,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11329:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            "value": "      Actual"
+                                                        },
+                                                        {
+                                                            "id": 4913,
+                                                            "name": "a",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4861,
+                                                            "src": "11345:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_0c86931dadd9b7dcb5fe0132c9f180edb774e714bd6d32d0fc56d5f9258e30e9",
+                                                                "typeString": "literal_string \"      Actual\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        ],
+                                                        "id": 4911,
+                                                        "name": "log_named_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2087,
+                                                        "src": "11306:13:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$returns$__$",
+                                                            "typeString": "function (string memory,int256)"
+                                                        }
+                                                    },
+                                                    "id": 4914,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11306:41:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4915,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11301:46:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "204d617820252044656c7461",
+                                                            "id": 4917,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11389:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            "value": " Max % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4918,
+                                                            "name": "maxPercentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4865,
+                                                            "src": "11405:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4919,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11422:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_476fe8c6eb42275e4a879ea3f97d4c8aa2f38a65ce8511d323ad7a22579f732d",
+                                                                "typeString": "literal_string \" Max % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4916,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "11366:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4920,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11366:59:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4921,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11361:64:6"
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "2020202020252044656c7461",
+                                                            "id": 4923,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11467:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            "value": "     % Delta"
+                                                        },
+                                                        {
+                                                            "id": 4924,
+                                                            "name": "percentDelta",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 4880,
+                                                            "src": "11483:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            }
+                                                        },
+                                                        {
+                                                            "hexValue": "3138",
+                                                            "id": 4925,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "11497:2:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            },
+                                                            "value": "18"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_3a4ade1e1607945ca481fbcd7c0ca5baa7e21e413316ae3997404f04177b03d7",
+                                                                "typeString": "literal_string \"     % Delta\""
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_int256",
+                                                                "typeString": "int256"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_rational_18_by_1",
+                                                                "typeString": "int_const 18"
+                                                            }
+                                                        ],
+                                                        "id": 4922,
+                                                        "name": "log_named_decimal_int",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2073,
+                                                        "src": "11444:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_string_memory_ptr_$_t_int256_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (string memory,int256,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 4926,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11444:56:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4927,
+                                                "nodeType": "EmitStatement",
+                                                "src": "11439:61:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "arguments": [],
+                                                    "expression": {
+                                                        "argumentTypes": [],
+                                                        "id": 4928,
+                                                        "name": "fail",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 2236,
+                                                        "src": "11514:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                                                            "typeString": "function ()"
+                                                        }
+                                                    },
+                                                    "id": 4929,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "11514:6:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 4930,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "11514:6:6"
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        "id": 4934,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assertApproxEqRel",
+                        "nameLocation": "10776:17:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 4868,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 4861,
+                                    "mutability": "mutable",
+                                    "name": "a",
+                                    "nameLocation": "10810:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10803:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4860,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10803:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4863,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "10828:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10821:8:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4862,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10821:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4865,
+                                    "mutability": "mutable",
+                                    "name": "maxPercentDelta",
+                                    "nameLocation": "10846:15:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10839:22:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_int256",
+                                        "typeString": "int256"
+                                    },
+                                    "typeName": {
+                                        "id": 4864,
+                                        "name": "int256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10839:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_int256",
+                                            "typeString": "int256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 4867,
+                                    "mutability": "mutable",
+                                    "name": "err",
+                                    "nameLocation": "10941:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 4934,
+                                    "src": "10927:17:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 4866,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "10927:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "10793:157:6"
+                        },
+                        "returnParameters": {
+                            "id": 4869,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "10968:0:6"
+                        },
+                        "scope": 4935,
+                        "src": "10767:770:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": true,
+                        "visibility": "internal"
+                    }
+                ],
+                "scope": 5991,
+                "src": "226:11313:6",
+                "usedErrors": []
+            },
+            {
+                "abstract": false,
+                "baseContracts": [],
+                "canonicalName": "stdError",
+                "contractDependencies": [],
+                "contractKind": "library",
+                "fullyImplemented": true,
+                "id": 5005,
+                "linearizedBaseContracts": [5005],
+                "name": "stdError",
+                "nameLocation": "11748:8:6",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "constant": true,
+                        "functionSelector": "10332977",
+                        "id": 4942,
+                        "mutability": "constant",
+                        "name": "assertionError",
+                        "nameLocation": "11785:14:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "11763:86:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4936,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "11763:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4939,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11826:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783031",
+                                    "id": 4940,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11844:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_1_by_1",
+                                        "typeString": "int_const 1"
+                                    },
+                                    "value": "0x01"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_1_by_1",
+                                        "typeString": "int_const 1"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4937,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "11802:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4938,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "11802:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4941,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "11802:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "8995290f",
+                        "id": 4949,
+                        "mutability": "constant",
+                        "name": "arithmeticError",
+                        "nameLocation": "11877:15:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "11855:87:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4943,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "11855:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4946,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11919:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783131",
+                                    "id": 4947,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "11937:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_17_by_1",
+                                        "typeString": "int_const 17"
+                                    },
+                                    "value": "0x11"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_17_by_1",
+                                        "typeString": "int_const 17"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4944,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "11895:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4945,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "11895:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4948,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "11895:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "fa784a44",
+                        "id": 4956,
+                        "mutability": "constant",
+                        "name": "divisionError",
+                        "nameLocation": "11970:13:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "11948:85:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4950,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "11948:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4953,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12010:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783132",
+                                    "id": 4954,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12028:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_18_by_1",
+                                        "typeString": "int_const 18"
+                                    },
+                                    "value": "0x12"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_18_by_1",
+                                        "typeString": "int_const 18"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4951,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "11986:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4952,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "11986:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4955,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "11986:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "1de45560",
+                        "id": 4963,
+                        "mutability": "constant",
+                        "name": "enumConversionError",
+                        "nameLocation": "12061:19:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12039:91:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4957,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12039:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4960,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12107:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783231",
+                                    "id": 4961,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12125:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_33_by_1",
+                                        "typeString": "int_const 33"
+                                    },
+                                    "value": "0x21"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_33_by_1",
+                                        "typeString": "int_const 33"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4958,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12083:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4959,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12083:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4962,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12083:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "d160e4de",
+                        "id": 4970,
+                        "mutability": "constant",
+                        "name": "encodeStorageError",
+                        "nameLocation": "12158:18:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12136:90:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4964,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12136:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4967,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12203:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783232",
+                                    "id": 4968,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12221:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_34_by_1",
+                                        "typeString": "int_const 34"
+                                    },
+                                    "value": "0x22"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_34_by_1",
+                                        "typeString": "int_const 34"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4965,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12179:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4966,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12179:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4969,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12179:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "b22dc54d",
+                        "id": 4977,
+                        "mutability": "constant",
+                        "name": "popError",
+                        "nameLocation": "12254:8:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12232:80:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4971,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12232:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4974,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12289:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783331",
+                                    "id": 4975,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12307:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_49_by_1",
+                                        "typeString": "int_const 49"
+                                    },
+                                    "value": "0x31"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_49_by_1",
+                                        "typeString": "int_const 49"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4972,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12265:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4973,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12265:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4976,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12265:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "05ee8612",
+                        "id": 4984,
+                        "mutability": "constant",
+                        "name": "indexOOBError",
+                        "nameLocation": "12340:13:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12318:85:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4978,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12318:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4981,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12380:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783332",
+                                    "id": 4982,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12398:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_50_by_1",
+                                        "typeString": "int_const 50"
+                                    },
+                                    "value": "0x32"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_50_by_1",
+                                        "typeString": "int_const 50"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4979,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12356:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4980,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12356:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4983,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12356:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "986c5f68",
+                        "id": 4991,
+                        "mutability": "constant",
+                        "name": "memOverflowError",
+                        "nameLocation": "12431:16:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12409:88:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4985,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12409:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4988,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12474:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783431",
+                                    "id": 4989,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12492:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_65_by_1",
+                                        "typeString": "int_const 65"
+                                    },
+                                    "value": "0x41"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_65_by_1",
+                                        "typeString": "int_const 65"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4986,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12450:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4987,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12450:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4990,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12450:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "b67689da",
+                        "id": 4998,
+                        "mutability": "constant",
+                        "name": "zeroVarError",
+                        "nameLocation": "12525:12:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12503:84:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4992,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12503:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "50616e69632875696e7432353629",
+                                    "id": 4995,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12564:16:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    "value": "Panic(uint256)"
+                                },
+                                {
+                                    "hexValue": "30783531",
+                                    "id": 4996,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "number",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12582:4:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_rational_81_by_1",
+                                        "typeString": "int_const 81"
+                                    },
+                                    "value": "0x51"
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_4e487b71539e0164c9d29506cc725e49342bcac15e0927282bf30fedfe1c7268",
+                                        "typeString": "literal_string \"Panic(uint256)\""
+                                    },
+                                    {
+                                        "typeIdentifier": "t_rational_81_by_1",
+                                        "typeString": "int_const 81"
+                                    }
+                                ],
+                                "expression": {
+                                    "id": 4993,
+                                    "name": "abi",
+                                    "nodeType": "Identifier",
+                                    "overloadedDeclarations": [],
+                                    "referencedDeclaration": -1,
+                                    "src": "12540:3:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_magic_abi",
+                                        "typeString": "abi"
+                                    }
+                                },
+                                "id": 4994,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "memberName": "encodeWithSignature",
+                                "nodeType": "MemberAccess",
+                                "src": "12540:23:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_function_abiencodewithsignature_pure$_t_string_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                    "typeString": "function (string memory) pure returns (bytes memory)"
+                                }
+                            },
+                            "id": 4997,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "functionCall",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12540:47:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    },
+                    {
+                        "constant": true,
+                        "functionSelector": "ac3d92c6",
+                        "id": 5004,
+                        "mutability": "constant",
+                        "name": "lowLevelError",
+                        "nameLocation": "12690:13:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5005,
+                        "src": "12668:47:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes_memory_ptr",
+                            "typeString": "bytes"
+                        },
+                        "typeName": {
+                            "id": 4999,
+                            "name": "bytes",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "12668:5:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_storage_ptr",
+                                "typeString": "bytes"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "hexValue": "",
+                                    "id": 5002,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "string",
+                                    "lValueRequested": false,
+                                    "nodeType": "Literal",
+                                    "src": "12712:2:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_stringliteral_c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+                                        "typeString": "literal_string \"\""
+                                    },
+                                    "value": ""
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_stringliteral_c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+                                        "typeString": "literal_string \"\""
+                                    }
+                                ],
+                                "id": 5001,
+                                "isConstant": false,
+                                "isLValue": false,
+                                "isPure": true,
+                                "lValueRequested": false,
+                                "nodeType": "ElementaryTypeNameExpression",
+                                "src": "12706:5:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_bytes_storage_ptr_$",
+                                    "typeString": "type(bytes storage pointer)"
+                                },
+                                "typeName": {
+                                    "id": 5000,
+                                    "name": "bytes",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "12706:5:6",
+                                    "typeDescriptions": {}
+                                }
+                            },
+                            "id": 5003,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "12706:9:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes_memory_ptr",
+                                "typeString": "bytes memory"
+                            }
+                        },
+                        "visibility": "public"
+                    }
+                ],
+                "scope": 5991,
+                "src": "11740:986:6",
+                "usedErrors": []
+            },
+            {
+                "canonicalName": "StdStorage",
+                "id": 5033,
+                "members": [
+                    {
+                        "constant": false,
+                        "id": 5013,
+                        "mutability": "mutable",
+                        "name": "slots",
+                        "nameLocation": "13019:5:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "12951:73:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                            "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                        },
+                        "typeName": {
+                            "id": 5012,
+                            "keyType": {
+                                "id": 5006,
+                                "name": "address",
+                                "nodeType": "ElementaryTypeName",
+                                "src": "12960:7:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_address",
+                                    "typeString": "address"
+                                }
+                            },
+                            "nodeType": "Mapping",
+                            "src": "12951:67:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                            },
+                            "valueType": {
+                                "id": 5011,
+                                "keyType": {
+                                    "id": 5007,
+                                    "name": "bytes4",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "12979:6:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    }
+                                },
+                                "nodeType": "Mapping",
+                                "src": "12971:46:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                    "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                },
+                                "valueType": {
+                                    "id": 5010,
+                                    "keyType": {
+                                        "id": 5008,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "12997:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "Mapping",
+                                    "src": "12989:27:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                        "typeString": "mapping(bytes32 => uint256)"
+                                    },
+                                    "valueType": {
+                                        "id": 5009,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13008:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5021,
+                        "mutability": "mutable",
+                        "name": "finds",
+                        "nameLocation": "13096:5:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13030:71:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                            "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                        },
+                        "typeName": {
+                            "id": 5020,
+                            "keyType": {
+                                "id": 5014,
+                                "name": "address",
+                                "nodeType": "ElementaryTypeName",
+                                "src": "13039:7:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_address",
+                                    "typeString": "address"
+                                }
+                            },
+                            "nodeType": "Mapping",
+                            "src": "13030:65:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                            },
+                            "valueType": {
+                                "id": 5019,
+                                "keyType": {
+                                    "id": 5015,
+                                    "name": "bytes4",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "13058:6:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    }
+                                },
+                                "nodeType": "Mapping",
+                                "src": "13050:44:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                    "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                },
+                                "valueType": {
+                                    "id": 5018,
+                                    "keyType": {
+                                        "id": 5016,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13077:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "Mapping",
+                                    "src": "13069:24:6",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                        "typeString": "mapping(bytes32 => bool)"
+                                    },
+                                    "valueType": {
+                                        "id": 5017,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13088:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5024,
+                        "mutability": "mutable",
+                        "name": "_keys",
+                        "nameLocation": "13118:5:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13108:15:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                            "typeString": "bytes32[]"
+                        },
+                        "typeName": {
+                            "baseType": {
+                                "id": 5022,
+                                "name": "bytes32",
+                                "nodeType": "ElementaryTypeName",
+                                "src": "13108:7:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_bytes32",
+                                    "typeString": "bytes32"
+                                }
+                            },
+                            "id": 5023,
+                            "nodeType": "ArrayTypeName",
+                            "src": "13108:9:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                "typeString": "bytes32[]"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5026,
+                        "mutability": "mutable",
+                        "name": "_sig",
+                        "nameLocation": "13136:4:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13129:11:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes4",
+                            "typeString": "bytes4"
+                        },
+                        "typeName": {
+                            "id": 5025,
+                            "name": "bytes4",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13129:6:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes4",
+                                "typeString": "bytes4"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5028,
+                        "mutability": "mutable",
+                        "name": "_depth",
+                        "nameLocation": "13154:6:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13146:14:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                        },
+                        "typeName": {
+                            "id": 5027,
+                            "name": "uint256",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13146:7:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_uint256",
+                                "typeString": "uint256"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5030,
+                        "mutability": "mutable",
+                        "name": "_target",
+                        "nameLocation": "13174:7:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13166:15:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_address",
+                            "typeString": "address"
+                        },
+                        "typeName": {
+                            "id": 5029,
+                            "name": "address",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13166:7:6",
+                            "stateMutability": "nonpayable",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_address",
+                                "typeString": "address"
+                            }
+                        },
+                        "visibility": "internal"
+                    },
+                    {
+                        "constant": false,
+                        "id": 5032,
+                        "mutability": "mutable",
+                        "name": "_set",
+                        "nameLocation": "13195:4:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5033,
+                        "src": "13187:12:6",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_bytes32",
+                            "typeString": "bytes32"
+                        },
+                        "typeName": {
+                            "id": 5031,
+                            "name": "bytes32",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "13187:7:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_bytes32",
+                                "typeString": "bytes32"
+                            }
+                        },
+                        "visibility": "internal"
+                    }
+                ],
+                "name": "StdStorage",
+                "nameLocation": "12934:10:6",
+                "nodeType": "StructDefinition",
+                "scope": 5991,
+                "src": "12927:275:6",
+                "visibility": "public"
+            },
+            {
+                "abstract": false,
+                "baseContracts": [],
+                "canonicalName": "stdStorage",
+                "contractDependencies": [],
+                "contractKind": "library",
+                "fullyImplemented": true,
+                "id": 5990,
+                "linearizedBaseContracts": [5990],
+                "name": "stdStorage",
+                "nameLocation": "13212:10:6",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "anonymous": false,
+                        "id": 5043,
+                        "name": "SlotFound",
+                        "nameLocation": "13235:9:6",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 5042,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5035,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "13253:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13245:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5034,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13245:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5037,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "fsig",
+                                    "nameLocation": "13265:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13258:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    },
+                                    "typeName": {
+                                        "id": 5036,
+                                        "name": "bytes4",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13258:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5039,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "keysHash",
+                                    "nameLocation": "13279:8:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13271:16:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5038,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13271:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5041,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "slot",
+                                    "nameLocation": "13294:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5043,
+                                    "src": "13289:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5040,
+                                        "name": "uint",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13289:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13244:55:6"
+                        },
+                        "src": "13229:71:6"
+                    },
+                    {
+                        "anonymous": false,
+                        "id": 5049,
+                        "name": "WARNING_UninitedSlot",
+                        "nameLocation": "13311:20:6",
+                        "nodeType": "EventDefinition",
+                        "parameters": {
+                            "id": 5048,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5045,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "13340:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5049,
+                                    "src": "13332:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5044,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13332:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5047,
+                                    "indexed": false,
+                                    "mutability": "mutable",
+                                    "name": "slot",
+                                    "nameLocation": "13350:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5049,
+                                    "src": "13345:9:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5046,
+                                        "name": "uint",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13345:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13331:24:6"
+                        },
+                        "src": "13305:51:6"
+                    },
+                    {
+                        "constant": true,
+                        "id": 5066,
+                        "mutability": "constant",
+                        "name": "vm_std_store",
+                        "nameLocation": "13382:12:6",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5990,
+                        "src": "13362:94:6",
+                        "stateVariable": true,
+                        "storageLocation": "default",
+                        "typeDescriptions": {
+                            "typeIdentifier": "t_contract$_Vm_$6200",
+                            "typeString": "contract Vm"
+                        },
+                        "typeName": {
+                            "id": 5051,
+                            "nodeType": "UserDefinedTypeName",
+                            "pathNode": {
+                                "id": 5050,
+                                "name": "Vm",
+                                "nodeType": "IdentifierPath",
+                                "referencedDeclaration": 6200,
+                                "src": "13362:2:6"
+                            },
+                            "referencedDeclaration": 6200,
+                            "src": "13362:2:6",
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "value": {
+                            "arguments": [
+                                {
+                                    "arguments": [
+                                        {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "hexValue": "6865766d20636865617420636f6465",
+                                                                    "id": 5060,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "string",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "13434:17:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_stringliteral_885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d",
+                                                                        "typeString": "literal_string \"hevm cheat code\""
+                                                                    },
+                                                                    "value": "hevm cheat code"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_stringliteral_885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d",
+                                                                        "typeString": "literal_string \"hevm cheat code\""
+                                                                    }
+                                                                ],
+                                                                "id": 5059,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "13424:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5061,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "13424:28:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        ],
+                                                        "id": 5058,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                        "src": "13416:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_type$_t_uint256_$",
+                                                            "typeString": "type(uint256)"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 5057,
+                                                            "name": "uint256",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "13416:7:6",
+                                                            "typeDescriptions": {}
+                                                        }
+                                                    },
+                                                    "id": 5062,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "typeConversion",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "13416:37:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                ],
+                                                "id": 5056,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "lValueRequested": false,
+                                                "nodeType": "ElementaryTypeNameExpression",
+                                                "src": "13408:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_type$_t_uint160_$",
+                                                    "typeString": "type(uint160)"
+                                                },
+                                                "typeName": {
+                                                    "id": 5055,
+                                                    "name": "uint160",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "13408:7:6",
+                                                    "typeDescriptions": {}
+                                                }
+                                            },
+                                            "id": 5063,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "typeConversion",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "13408:46:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint160",
+                                                "typeString": "uint160"
+                                            }
+                                        }
+                                    ],
+                                    "expression": {
+                                        "argumentTypes": [
+                                            {
+                                                "typeIdentifier": "t_uint160",
+                                                "typeString": "uint160"
+                                            }
+                                        ],
+                                        "id": 5054,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": true,
+                                        "lValueRequested": false,
+                                        "nodeType": "ElementaryTypeNameExpression",
+                                        "src": "13400:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_type$_t_address_$",
+                                            "typeString": "type(address)"
+                                        },
+                                        "typeName": {
+                                            "id": 5053,
+                                            "name": "address",
+                                            "nodeType": "ElementaryTypeName",
+                                            "src": "13400:7:6",
+                                            "typeDescriptions": {}
+                                        }
+                                    },
+                                    "id": 5064,
+                                    "isConstant": false,
+                                    "isLValue": false,
+                                    "isPure": true,
+                                    "kind": "typeConversion",
+                                    "lValueRequested": false,
+                                    "names": [],
+                                    "nodeType": "FunctionCall",
+                                    "src": "13400:55:6",
+                                    "tryCall": false,
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                }
+                            ],
+                            "expression": {
+                                "argumentTypes": [
+                                    {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    }
+                                ],
+                                "id": 5052,
+                                "name": "Vm",
+                                "nodeType": "Identifier",
+                                "overloadedDeclarations": [],
+                                "referencedDeclaration": 6200,
+                                "src": "13397:2:6",
+                                "typeDescriptions": {
+                                    "typeIdentifier": "t_type$_t_contract$_Vm_$6200_$",
+                                    "typeString": "type(contract Vm)"
+                                }
+                            },
+                            "id": 5065,
+                            "isConstant": false,
+                            "isLValue": false,
+                            "isPure": true,
+                            "kind": "typeConversion",
+                            "lValueRequested": false,
+                            "names": [],
+                            "nodeType": "FunctionCall",
+                            "src": "13397:59:6",
+                            "tryCall": false,
+                            "typeDescriptions": {
+                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                "typeString": "contract Vm"
+                            }
+                        },
+                        "visibility": "private"
+                    },
+                    {
+                        "body": {
+                            "id": 5083,
+                            "nodeType": "Block",
+                            "src": "13572:56:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "id": 5078,
+                                                                "name": "sigStr",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5068,
+                                                                "src": "13612:6:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                                    "typeString": "string memory"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_string_memory_ptr",
+                                                                    "typeString": "string memory"
+                                                                }
+                                                            ],
+                                                            "id": 5077,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "13606:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_bytes_storage_ptr_$",
+                                                                "typeString": "type(bytes storage pointer)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5076,
+                                                                "name": "bytes",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "13606:5:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5079,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "13606:13:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "id": 5075,
+                                                    "name": "keccak256",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": -8,
+                                                    "src": "13596:9:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                        "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                    }
+                                                },
+                                                "id": 5080,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "13596:24:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5074,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "nodeType": "ElementaryTypeNameExpression",
+                                            "src": "13589:6:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_type$_t_bytes4_$",
+                                                "typeString": "type(bytes4)"
+                                            },
+                                            "typeName": {
+                                                "id": 5073,
+                                                "name": "bytes4",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "13589:6:6",
+                                                "typeDescriptions": {}
+                                            }
+                                        },
+                                        "id": 5081,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "typeConversion",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "13589:32:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5072,
+                                    "id": 5082,
+                                    "nodeType": "Return",
+                                    "src": "13582:39:6"
+                                }
+                            ]
+                        },
+                        "id": 5084,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "sigs",
+                        "nameLocation": "13472:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5069,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5068,
+                                    "mutability": "mutable",
+                                    "name": "sigStr",
+                                    "nameLocation": "13500:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5084,
+                                    "src": "13486:20:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 5067,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13486:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13476:36:6"
+                        },
+                        "returnParameters": {
+                            "id": 5072,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5071,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5084,
+                                    "src": "13560:6:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    },
+                                    "typeName": {
+                                        "id": 5070,
+                                        "name": "bytes4",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "13560:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "13559:8:6"
+                        },
+                        "scope": 5990,
+                        "src": "13463:165:6",
+                        "stateMutability": "pure",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5528,
+                            "nodeType": "Block",
+                            "src": "14242:3014:6",
+                            "statements": [
+                                {
+                                    "assignments": [5094],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5094,
+                                            "mutability": "mutable",
+                                            "name": "who",
+                                            "nameLocation": "14260:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14252:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            },
+                                            "typeName": {
+                                                "id": 5093,
+                                                "name": "address",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14252:7:6",
+                                                "stateMutability": "nonpayable",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5097,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5095,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14266:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5096,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_target",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5030,
+                                        "src": "14266:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14252:26:6"
+                                },
+                                {
+                                    "assignments": [5099],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5099,
+                                            "mutability": "mutable",
+                                            "name": "fsig",
+                                            "nameLocation": "14295:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14288:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            },
+                                            "typeName": {
+                                                "id": 5098,
+                                                "name": "bytes4",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14288:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5102,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5100,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14302:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5101,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_sig",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5026,
+                                        "src": "14302:9:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14288:23:6"
+                                },
+                                {
+                                    "assignments": [5104],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5104,
+                                            "mutability": "mutable",
+                                            "name": "field_depth",
+                                            "nameLocation": "14329:11:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14321:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 5103,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14321:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5107,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5105,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14343:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5106,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_depth",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5028,
+                                        "src": "14343:11:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14321:33:6"
+                                },
+                                {
+                                    "assignments": [5112],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5112,
+                                            "mutability": "mutable",
+                                            "name": "ins",
+                                            "nameLocation": "14381:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14364:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                "typeString": "bytes32[]"
+                                            },
+                                            "typeName": {
+                                                "baseType": {
+                                                    "id": 5110,
+                                                    "name": "bytes32",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "14364:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5111,
+                                                "nodeType": "ArrayTypeName",
+                                                "src": "14364:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                                    "typeString": "bytes32[]"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5115,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5113,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5088,
+                                            "src": "14387:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5114,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_keys",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5024,
+                                        "src": "14387:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                            "typeString": "bytes32[] storage ref"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14364:33:6"
+                                },
+                                {
+                                    "condition": {
+                                        "baseExpression": {
+                                            "baseExpression": {
+                                                "baseExpression": {
+                                                    "expression": {
+                                                        "id": 5116,
+                                                        "name": "self",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5088,
+                                                        "src": "14448:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 5117,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "finds",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5021,
+                                                    "src": "14448:10:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                    }
+                                                },
+                                                "id": 5119,
+                                                "indexExpression": {
+                                                    "id": 5118,
+                                                    "name": "who",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5094,
+                                                    "src": "14459:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "14448:15:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                }
+                                            },
+                                            "id": 5121,
+                                            "indexExpression": {
+                                                "id": 5120,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5099,
+                                                "src": "14464:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "IndexAccess",
+                                            "src": "14448:21:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                "typeString": "mapping(bytes32 => bool)"
+                                            }
+                                        },
+                                        "id": 5129,
+                                        "indexExpression": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5125,
+                                                            "name": "ins",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5112,
+                                                            "src": "14497:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "id": 5126,
+                                                            "name": "field_depth",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5104,
+                                                            "src": "14502:11:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 5123,
+                                                            "name": "abi",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -1,
+                                                            "src": "14480:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_abi",
+                                                                "typeString": "abi"
+                                                            }
+                                                        },
+                                                        "id": 5124,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "memberName": "encodePacked",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "14480:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                            "typeString": "function () pure returns (bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 5127,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "14480:34:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 5122,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "14470:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 5128,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "14470:45:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "IndexAccess",
+                                        "src": "14448:68:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5146,
+                                    "nodeType": "IfStatement",
+                                    "src": "14444:174:6",
+                                    "trueBody": {
+                                        "id": 5145,
+                                        "nodeType": "Block",
+                                        "src": "14518:100:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "baseExpression": {
+                                                        "baseExpression": {
+                                                            "baseExpression": {
+                                                                "expression": {
+                                                                    "id": 5130,
+                                                                    "name": "self",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5088,
+                                                                    "src": "14539:4:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                    }
+                                                                },
+                                                                "id": 5131,
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "memberName": "slots",
+                                                                "nodeType": "MemberAccess",
+                                                                "referencedDeclaration": 5013,
+                                                                "src": "14539:10:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                    "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                                }
+                                                            },
+                                                            "id": 5133,
+                                                            "indexExpression": {
+                                                                "id": 5132,
+                                                                "name": "who",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5094,
+                                                                "src": "14550:3:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_address",
+                                                                    "typeString": "address"
+                                                                }
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "14539:15:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                                "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                            }
+                                                        },
+                                                        "id": 5135,
+                                                        "indexExpression": {
+                                                            "id": 5134,
+                                                            "name": "fsig",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5099,
+                                                            "src": "14555:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes4",
+                                                                "typeString": "bytes4"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "14539:21:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                            "typeString": "mapping(bytes32 => uint256)"
+                                                        }
+                                                    },
+                                                    "id": 5143,
+                                                    "indexExpression": {
+                                                        "arguments": [
+                                                            {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5139,
+                                                                        "name": "ins",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5112,
+                                                                        "src": "14588:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                            "typeString": "bytes32[] memory"
+                                                                        }
+                                                                    },
+                                                                    {
+                                                                        "id": 5140,
+                                                                        "name": "field_depth",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5104,
+                                                                        "src": "14593:11:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                            "typeString": "bytes32[] memory"
+                                                                        },
+                                                                        {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "id": 5137,
+                                                                        "name": "abi",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": -1,
+                                                                        "src": "14571:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_magic_abi",
+                                                                            "typeString": "abi"
+                                                                        }
+                                                                    },
+                                                                    "id": 5138,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "encodePacked",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "src": "14571:16:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                    }
+                                                                },
+                                                                "id": 5141,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "14571:34:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                    "typeString": "bytes memory"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                    "typeString": "bytes memory"
+                                                                }
+                                                            ],
+                                                            "id": 5136,
+                                                            "name": "keccak256",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -8,
+                                                            "src": "14561:9:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                            }
+                                                        },
+                                                        "id": 5142,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "14561:45:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "14539:68:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "functionReturnParameters": 5092,
+                                                "id": 5144,
+                                                "nodeType": "Return",
+                                                "src": "14532:75:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "assignments": [5148],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5148,
+                                            "mutability": "mutable",
+                                            "name": "cald",
+                                            "nameLocation": "14640:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14627:17:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 5147,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14627:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5156,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 5151,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5099,
+                                                "src": "14664:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5153,
+                                                        "name": "ins",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5112,
+                                                        "src": "14678:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    ],
+                                                    "id": 5152,
+                                                    "name": "flatten",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5989,
+                                                    "src": "14670:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_pure$_t_array$_t_bytes32_$dyn_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes32[] memory) pure returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5154,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "14670:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5149,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "14647:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 5150,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "encodePacked",
+                                            "nodeType": "MemberAccess",
+                                            "src": "14647:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function () pure returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 5155,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "14647:36:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14627:56:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [],
+                                        "expression": {
+                                            "argumentTypes": [],
+                                            "expression": {
+                                                "id": 5157,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "14693:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5159,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "record",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6139,
+                                            "src": "14693:19:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$__$returns$__$",
+                                                "typeString": "function () external"
+                                            }
+                                        },
+                                        "id": 5160,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "14693:21:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5161,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "14693:21:6"
+                                },
+                                {
+                                    "assignments": [5163],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5163,
+                                            "mutability": "mutable",
+                                            "name": "fdat",
+                                            "nameLocation": "14732:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14724:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5162,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "14724:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5164,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14724:12:6"
+                                },
+                                {
+                                    "id": 5181,
+                                    "nodeType": "Block",
+                                    "src": "14746:126:6",
+                                    "statements": [
+                                        {
+                                            "assignments": [null, 5166],
+                                            "declarations": [
+                                                null,
+                                                {
+                                                    "constant": false,
+                                                    "id": 5166,
+                                                    "mutability": "mutable",
+                                                    "name": "rdat",
+                                                    "nameLocation": "14776:4:6",
+                                                    "nodeType": "VariableDeclaration",
+                                                    "scope": 5181,
+                                                    "src": "14763:17:6",
+                                                    "stateVariable": false,
+                                                    "storageLocation": "memory",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5165,
+                                                        "name": "bytes",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "14763:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                                            "typeString": "bytes"
+                                                        }
+                                                    },
+                                                    "visibility": "internal"
+                                                }
+                                            ],
+                                            "id": 5171,
+                                            "initialValue": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5169,
+                                                        "name": "cald",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5148,
+                                                        "src": "14799:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 5167,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5094,
+                                                        "src": "14784:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    },
+                                                    "id": 5168,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "staticcall",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "14784:14:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes memory) view returns (bool,bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5170,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "14784:20:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                    "typeString": "tuple(bool,bytes memory)"
+                                                }
+                                            },
+                                            "nodeType": "VariableDeclarationStatement",
+                                            "src": "14760:44:6"
+                                        },
+                                        {
+                                            "expression": {
+                                                "id": 5179,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftHandSide": {
+                                                    "id": 5172,
+                                                    "name": "fdat",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5163,
+                                                    "src": "14818:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "Assignment",
+                                                "operator": "=",
+                                                "rightHandSide": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5174,
+                                                            "name": "rdat",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5166,
+                                                            "src": "14840:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "commonType": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            "id": 5177,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "leftExpression": {
+                                                                "hexValue": "3332",
+                                                                "id": 5175,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "14846:2:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_32_by_1",
+                                                                    "typeString": "int_const 32"
+                                                                },
+                                                                "value": "32"
+                                                            },
+                                                            "nodeType": "BinaryOperation",
+                                                            "operator": "*",
+                                                            "rightExpression": {
+                                                                "id": 5176,
+                                                                "name": "field_depth",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5104,
+                                                                "src": "14849:11:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "src": "14846:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 5173,
+                                                        "name": "bytesToBytes32",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5948,
+                                                        "src": "14825:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_pure$_t_bytes_memory_ptr_$_t_uint256_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory,uint256) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5178,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "14825:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "src": "14818:43:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "id": 5180,
+                                            "nodeType": "ExpressionStatement",
+                                            "src": "14818:43:6"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "assignments": [5186, null],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5186,
+                                            "mutability": "mutable",
+                                            "name": "reads",
+                                            "nameLocation": "14900:5:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5528,
+                                            "src": "14883:22:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                "typeString": "bytes32[]"
+                                            },
+                                            "typeName": {
+                                                "baseType": {
+                                                    "id": 5184,
+                                                    "name": "bytes32",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "14883:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5185,
+                                                "nodeType": "ArrayTypeName",
+                                                "src": "14883:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                                    "typeString": "bytes32[]"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        },
+                                        null
+                                    ],
+                                    "id": 5194,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5191,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5094,
+                                                        "src": "14941:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    ],
+                                                    "id": 5190,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "14933:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_address_$",
+                                                        "typeString": "type(address)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5189,
+                                                        "name": "address",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "14933:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5192,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "14933:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5187,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "14911:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5188,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "accesses",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6150,
+                                            "src": "14911:21:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$returns$_t_array$_t_bytes32_$dyn_memory_ptr_$_t_array$_t_bytes32_$dyn_memory_ptr_$",
+                                                "typeString": "function (address) external returns (bytes32[] memory,bytes32[] memory)"
+                                            }
+                                        },
+                                        "id": 5193,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "14911:35:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$_t_array$_t_bytes32_$dyn_memory_ptr_$_t_array$_t_bytes32_$dyn_memory_ptr_$",
+                                            "typeString": "tuple(bytes32[] memory,bytes32[] memory)"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "14882:64:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 5198,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "expression": {
+                                                "id": 5195,
+                                                "name": "reads",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5186,
+                                                "src": "14960:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                    "typeString": "bytes32[] memory"
+                                                }
+                                            },
+                                            "id": 5196,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "length",
+                                            "nodeType": "MemberAccess",
+                                            "src": "14960:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "==",
+                                        "rightExpression": {
+                                            "hexValue": "31",
+                                            "id": 5197,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "14976:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_1_by_1",
+                                                "typeString": "int_const 1"
+                                            },
+                                            "value": "1"
+                                        },
+                                        "src": "14960:17:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "falseBody": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 5300,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "expression": {
+                                                    "id": 5297,
+                                                    "name": "reads",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5186,
+                                                    "src": "15638:5:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                        "typeString": "bytes32[] memory"
+                                                    }
+                                                },
+                                                "id": 5298,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "length",
+                                                "nodeType": "MemberAccess",
+                                                "src": "15638:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "hexValue": "31",
+                                                "id": 5299,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "15653:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_1_by_1",
+                                                    "typeString": "int_const 1"
+                                                },
+                                                "value": "1"
+                                            },
+                                            "src": "15638:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseBody": {
+                                            "id": 5476,
+                                            "nodeType": "Block",
+                                            "src": "16876:77:6",
+                                            "statements": [
+                                                {
+                                                    "expression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "66616c7365",
+                                                                "id": 5472,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "bool",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "16898:5:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                },
+                                                                "value": "false"
+                                                            },
+                                                            {
+                                                                "hexValue": "4e6f2073746f726167652075736520646574656374656420666f7220746172676574",
+                                                                "id": 5473,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "string",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "16905:36:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_stringliteral_2d47527d82ff490318d5b489ec83c9a0ae26d9e8e2e75850ef5c9e43da453070",
+                                                                    "typeString": "literal_string \"No storage use detected for target\""
+                                                                },
+                                                                "value": "No storage use detected for target"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_bool",
+                                                                    "typeString": "bool"
+                                                                },
+                                                                {
+                                                                    "typeIdentifier": "t_stringliteral_2d47527d82ff490318d5b489ec83c9a0ae26d9e8e2e75850ef5c9e43da453070",
+                                                                    "typeString": "literal_string \"No storage use detected for target\""
+                                                                }
+                                                            ],
+                                                            "id": 5471,
+                                                            "name": "require",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [
+                                                                -18, -18
+                                                            ],
+                                                            "referencedDeclaration": -18,
+                                                            "src": "16890:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                                "typeString": "function (bool,string memory) pure"
+                                                            }
+                                                        },
+                                                        "id": 5474,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "16890:52:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_tuple$__$",
+                                                            "typeString": "tuple()"
+                                                        }
+                                                    },
+                                                    "id": 5475,
+                                                    "nodeType": "ExpressionStatement",
+                                                    "src": "16890:52:6"
+                                                }
+                                            ]
+                                        },
+                                        "id": 5477,
+                                        "nodeType": "IfStatement",
+                                        "src": "15634:1319:6",
+                                        "trueBody": {
+                                            "id": 5470,
+                                            "nodeType": "Block",
+                                            "src": "15656:1214:6",
+                                            "statements": [
+                                                {
+                                                    "body": {
+                                                        "id": 5468,
+                                                        "nodeType": "Block",
+                                                        "src": "15713:1147:6",
+                                                        "statements": [
+                                                            {
+                                                                "assignments": [
+                                                                    5313
+                                                                ],
+                                                                "declarations": [
+                                                                    {
+                                                                        "constant": false,
+                                                                        "id": 5313,
+                                                                        "mutability": "mutable",
+                                                                        "name": "prev",
+                                                                        "nameLocation": "15739:4:6",
+                                                                        "nodeType": "VariableDeclaration",
+                                                                        "scope": 5468,
+                                                                        "src": "15731:12:6",
+                                                                        "stateVariable": false,
+                                                                        "storageLocation": "default",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        },
+                                                                        "typeName": {
+                                                                            "id": 5312,
+                                                                            "name": "bytes32",
+                                                                            "nodeType": "ElementaryTypeName",
+                                                                            "src": "15731:7:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "visibility": "internal"
+                                                                    }
+                                                                ],
+                                                                "id": 5321,
+                                                                "initialValue": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5316,
+                                                                            "name": "who",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5094,
+                                                                            "src": "15764:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "baseExpression": {
+                                                                                "id": 5317,
+                                                                                "name": "reads",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5186,
+                                                                                "src": "15769:5:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                    "typeString": "bytes32[] memory"
+                                                                                }
+                                                                            },
+                                                                            "id": 5319,
+                                                                            "indexExpression": {
+                                                                                "id": 5318,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5302,
+                                                                                "src": "15775:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "isConstant": false,
+                                                                            "isLValue": true,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "IndexAccess",
+                                                                            "src": "15769:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5314,
+                                                                            "name": "vm_std_store",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5066,
+                                                                            "src": "15746:12:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                "typeString": "contract Vm"
+                                                                            }
+                                                                        },
+                                                                        "id": 5315,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "load",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 6022,
+                                                                        "src": "15746:17:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$returns$_t_bytes32_$",
+                                                                            "typeString": "function (address,bytes32) external returns (bytes32)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5320,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15746:32:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    }
+                                                                },
+                                                                "nodeType": "VariableDeclarationStatement",
+                                                                "src": "15731:47:6"
+                                                            },
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    },
+                                                                    "id": 5327,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 5322,
+                                                                        "name": "prev",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5313,
+                                                                        "src": "15800:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "==",
+                                                                    "rightExpression": {
+                                                                        "arguments": [
+                                                                            {
+                                                                                "hexValue": "30",
+                                                                                "id": 5325,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": true,
+                                                                                "kind": "number",
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "Literal",
+                                                                                "src": "15816:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                                    "typeString": "int_const 0"
+                                                                                },
+                                                                                "value": "0"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "argumentTypes": [
+                                                                                {
+                                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                                    "typeString": "int_const 0"
+                                                                                }
+                                                                            ],
+                                                                            "id": 5324,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                            "src": "15808:7:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                                "typeString": "type(bytes32)"
+                                                                            },
+                                                                            "typeName": {
+                                                                                "id": 5323,
+                                                                                "name": "bytes32",
+                                                                                "nodeType": "ElementaryTypeName",
+                                                                                "src": "15808:7:6",
+                                                                                "typeDescriptions": {}
+                                                                            }
+                                                                        },
+                                                                        "id": 5326,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "typeConversion",
+                                                                        "lValueRequested": false,
+                                                                        "names": [],
+                                                                        "nodeType": "FunctionCall",
+                                                                        "src": "15808:10:6",
+                                                                        "tryCall": false,
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        }
+                                                                    },
+                                                                    "src": "15800:18:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "id": 5339,
+                                                                "nodeType": "IfStatement",
+                                                                "src": "15796:114:6",
+                                                                "trueBody": {
+                                                                    "id": 5338,
+                                                                    "nodeType": "Block",
+                                                                    "src": "15820:90:6",
+                                                                    "statements": [
+                                                                        {
+                                                                            "eventCall": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5329,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "15868:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "baseExpression": {
+                                                                                                    "id": 5332,
+                                                                                                    "name": "reads",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5186,
+                                                                                                    "src": "15881:5:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                        "typeString": "bytes32[] memory"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5334,
+                                                                                                "indexExpression": {
+                                                                                                    "id": 5333,
+                                                                                                    "name": "i",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5302,
+                                                                                                    "src": "15887:1:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_uint256",
+                                                                                                        "typeString": "uint256"
+                                                                                                    }
+                                                                                                },
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "nodeType": "IndexAccess",
+                                                                                                "src": "15881:8:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5331,
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": false,
+                                                                                            "isPure": true,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                                            "src": "15873:7:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                                "typeString": "type(uint256)"
+                                                                                            },
+                                                                                            "typeName": {
+                                                                                                "id": 5330,
+                                                                                                "name": "uint256",
+                                                                                                "nodeType": "ElementaryTypeName",
+                                                                                                "src": "15873:7:6",
+                                                                                                "typeDescriptions": {}
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5335,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "typeConversion",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "15873:17:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    ],
+                                                                                    "id": 5328,
+                                                                                    "name": "WARNING_UninitedSlot",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5049,
+                                                                                    "src": "15847:20:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                                                        "typeString": "function (address,uint256)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5336,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "15847:44:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                                    "typeString": "tuple()"
+                                                                                }
+                                                                            },
+                                                                            "id": 5337,
+                                                                            "nodeType": "EmitStatement",
+                                                                            "src": "15842:49:6"
+                                                                        }
+                                                                    ]
+                                                                }
+                                                            },
+                                                            {
+                                                                "expression": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5343,
+                                                                            "name": "who",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5094,
+                                                                            "src": "15971:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "baseExpression": {
+                                                                                "id": 5344,
+                                                                                "name": "reads",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5186,
+                                                                                "src": "15976:5:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                    "typeString": "bytes32[] memory"
+                                                                                }
+                                                                            },
+                                                                            "id": 5346,
+                                                                            "indexExpression": {
+                                                                                "id": 5345,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5302,
+                                                                                "src": "15982:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "isConstant": false,
+                                                                            "isLValue": true,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "IndexAccess",
+                                                                            "src": "15976:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "arguments": [
+                                                                                {
+                                                                                    "hexValue": "1337",
+                                                                                    "id": 5349,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "hexString",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "15994:9:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    },
+                                                                                    "value": "\u00137"
+                                                                                }
+                                                                            ],
+                                                                            "expression": {
+                                                                                "argumentTypes": [
+                                                                                    {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    }
+                                                                                ],
+                                                                                "id": 5348,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": true,
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                                "src": "15986:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                                    "typeString": "type(bytes32)"
+                                                                                },
+                                                                                "typeName": {
+                                                                                    "id": 5347,
+                                                                                    "name": "bytes32",
+                                                                                    "nodeType": "ElementaryTypeName",
+                                                                                    "src": "15986:7:6",
+                                                                                    "typeDescriptions": {}
+                                                                                }
+                                                                            },
+                                                                            "id": 5350,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "kind": "typeConversion",
+                                                                            "lValueRequested": false,
+                                                                            "names": [],
+                                                                            "nodeType": "FunctionCall",
+                                                                            "src": "15986:18:6",
+                                                                            "tryCall": false,
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5340,
+                                                                            "name": "vm_std_store",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5066,
+                                                                            "src": "15952:12:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                "typeString": "contract Vm"
+                                                                            }
+                                                                        },
+                                                                        "id": 5342,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "store",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 6031,
+                                                                        "src": "15952:18:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                                            "typeString": "function (address,bytes32,bytes32) external"
+                                                                        }
+                                                                    },
+                                                                    "id": 5351,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15952:53:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_tuple$__$",
+                                                                        "typeString": "tuple()"
+                                                                    }
+                                                                },
+                                                                "id": 5352,
+                                                                "nodeType": "ExpressionStatement",
+                                                                "src": "15952:53:6"
+                                                            },
+                                                            {
+                                                                "assignments": [
+                                                                    5354
+                                                                ],
+                                                                "declarations": [
+                                                                    {
+                                                                        "constant": false,
+                                                                        "id": 5354,
+                                                                        "mutability": "mutable",
+                                                                        "name": "success",
+                                                                        "nameLocation": "16028:7:6",
+                                                                        "nodeType": "VariableDeclaration",
+                                                                        "scope": 5468,
+                                                                        "src": "16023:12:6",
+                                                                        "stateVariable": false,
+                                                                        "storageLocation": "default",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        },
+                                                                        "typeName": {
+                                                                            "id": 5353,
+                                                                            "name": "bool",
+                                                                            "nodeType": "ElementaryTypeName",
+                                                                            "src": "16023:4:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bool",
+                                                                                "typeString": "bool"
+                                                                            }
+                                                                        },
+                                                                        "visibility": "internal"
+                                                                    }
+                                                                ],
+                                                                "id": 5355,
+                                                                "nodeType": "VariableDeclarationStatement",
+                                                                "src": "16023:12:6"
+                                                            },
+                                                            {
+                                                                "assignments": [
+                                                                    5357
+                                                                ],
+                                                                "declarations": [
+                                                                    {
+                                                                        "constant": false,
+                                                                        "id": 5357,
+                                                                        "mutability": "mutable",
+                                                                        "name": "rdat",
+                                                                        "nameLocation": "16066:4:6",
+                                                                        "nodeType": "VariableDeclaration",
+                                                                        "scope": 5468,
+                                                                        "src": "16053:17:6",
+                                                                        "stateVariable": false,
+                                                                        "storageLocation": "memory",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                            "typeString": "bytes"
+                                                                        },
+                                                                        "typeName": {
+                                                                            "id": 5356,
+                                                                            "name": "bytes",
+                                                                            "nodeType": "ElementaryTypeName",
+                                                                            "src": "16053:5:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes_storage_ptr",
+                                                                                "typeString": "bytes"
+                                                                            }
+                                                                        },
+                                                                        "visibility": "internal"
+                                                                    }
+                                                                ],
+                                                                "id": 5358,
+                                                                "nodeType": "VariableDeclarationStatement",
+                                                                "src": "16053:17:6"
+                                                            },
+                                                            {
+                                                                "id": 5377,
+                                                                "nodeType": "Block",
+                                                                "src": "16088:144:6",
+                                                                "statements": [
+                                                                    {
+                                                                        "expression": {
+                                                                            "id": 5366,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftHandSide": {
+                                                                                "components": [
+                                                                                    {
+                                                                                        "id": 5359,
+                                                                                        "name": "success",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5354,
+                                                                                        "src": "16111:7:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bool",
+                                                                                            "typeString": "bool"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "id": 5360,
+                                                                                        "name": "rdat",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5357,
+                                                                                        "src": "16120:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "id": 5361,
+                                                                                "isConstant": false,
+                                                                                "isInlineArray": false,
+                                                                                "isLValue": true,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": true,
+                                                                                "nodeType": "TupleExpression",
+                                                                                "src": "16110:15:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                                                    "typeString": "tuple(bool,bytes memory)"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "Assignment",
+                                                                            "operator": "=",
+                                                                            "rightHandSide": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5364,
+                                                                                        "name": "cald",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5148,
+                                                                                        "src": "16143:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    ],
+                                                                                    "expression": {
+                                                                                        "id": 5362,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "16128:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5363,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": false,
+                                                                                    "memberName": "staticcall",
+                                                                                    "nodeType": "MemberAccess",
+                                                                                    "src": "16128:14:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                                                        "typeString": "function (bytes memory) view returns (bool,bytes memory)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5365,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16128:20:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                                                    "typeString": "tuple(bool,bytes memory)"
+                                                                                }
+                                                                            },
+                                                                            "src": "16110:38:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_tuple$__$",
+                                                                                "typeString": "tuple()"
+                                                                            }
+                                                                        },
+                                                                        "id": 5367,
+                                                                        "nodeType": "ExpressionStatement",
+                                                                        "src": "16110:38:6"
+                                                                    },
+                                                                    {
+                                                                        "expression": {
+                                                                            "id": 5375,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftHandSide": {
+                                                                                "id": 5368,
+                                                                                "name": "fdat",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5163,
+                                                                                "src": "16170:4:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "Assignment",
+                                                                            "operator": "=",
+                                                                            "rightHandSide": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5370,
+                                                                                        "name": "rdat",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5357,
+                                                                                        "src": "16192:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "commonType": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        },
+                                                                                        "id": 5373,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "leftExpression": {
+                                                                                            "hexValue": "3332",
+                                                                                            "id": 5371,
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": false,
+                                                                                            "isPure": true,
+                                                                                            "kind": "number",
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "Literal",
+                                                                                            "src": "16198:2:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_rational_32_by_1",
+                                                                                                "typeString": "int_const 32"
+                                                                                            },
+                                                                                            "value": "32"
+                                                                                        },
+                                                                                        "nodeType": "BinaryOperation",
+                                                                                        "operator": "*",
+                                                                                        "rightExpression": {
+                                                                                            "id": 5372,
+                                                                                            "name": "field_depth",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5104,
+                                                                                            "src": "16201:11:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_uint256",
+                                                                                                "typeString": "uint256"
+                                                                                            }
+                                                                                        },
+                                                                                        "src": "16198:14:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                            "typeString": "bytes memory"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    ],
+                                                                                    "id": 5369,
+                                                                                    "name": "bytesToBytes32",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5948,
+                                                                                    "src": "16177:14:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_internal_pure$_t_bytes_memory_ptr_$_t_uint256_$returns$_t_bytes32_$",
+                                                                                        "typeString": "function (bytes memory,uint256) pure returns (bytes32)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5374,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16177:36:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            },
+                                                                            "src": "16170:43:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "id": 5376,
+                                                                        "nodeType": "ExpressionStatement",
+                                                                        "src": "16170:43:6"
+                                                                    }
+                                                                ]
+                                                            },
+                                                            {
+                                                                "condition": {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    },
+                                                                    "id": 5385,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 5378,
+                                                                        "name": "success",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5354,
+                                                                        "src": "16254:7:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "&&",
+                                                                    "rightExpression": {
+                                                                        "commonType": {
+                                                                            "typeIdentifier": "t_bytes32",
+                                                                            "typeString": "bytes32"
+                                                                        },
+                                                                        "id": 5384,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "leftExpression": {
+                                                                            "id": 5379,
+                                                                            "name": "fdat",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5163,
+                                                                            "src": "16265:4:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "nodeType": "BinaryOperation",
+                                                                        "operator": "==",
+                                                                        "rightExpression": {
+                                                                            "arguments": [
+                                                                                {
+                                                                                    "hexValue": "1337",
+                                                                                    "id": 5382,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "hexString",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "16281:9:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    },
+                                                                                    "value": "\u00137"
+                                                                                }
+                                                                            ],
+                                                                            "expression": {
+                                                                                "argumentTypes": [
+                                                                                    {
+                                                                                        "typeIdentifier": "t_stringliteral_2636a8beb2c41b8ccafa9a55a5a5e333892a83b491df3a67d2768946a9f9c6dc",
+                                                                                        "typeString": "literal_string hex\"1337\""
+                                                                                    }
+                                                                                ],
+                                                                                "id": 5381,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": true,
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                                "src": "16273:7:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                                    "typeString": "type(bytes32)"
+                                                                                },
+                                                                                "typeName": {
+                                                                                    "id": 5380,
+                                                                                    "name": "bytes32",
+                                                                                    "nodeType": "ElementaryTypeName",
+                                                                                    "src": "16273:7:6",
+                                                                                    "typeDescriptions": {}
+                                                                                }
+                                                                            },
+                                                                            "id": 5383,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "kind": "typeConversion",
+                                                                            "lValueRequested": false,
+                                                                            "names": [],
+                                                                            "nodeType": "FunctionCall",
+                                                                            "src": "16273:18:6",
+                                                                            "tryCall": false,
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        "src": "16265:26:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        }
+                                                                    },
+                                                                    "src": "16254:37:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bool",
+                                                                        "typeString": "bool"
+                                                                    }
+                                                                },
+                                                                "id": 5457,
+                                                                "nodeType": "IfStatement",
+                                                                "src": "16250:539:6",
+                                                                "trueBody": {
+                                                                    "id": 5456,
+                                                                    "nodeType": "Block",
+                                                                    "src": "16293:496:6",
+                                                                    "statements": [
+                                                                        {
+                                                                            "eventCall": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5387,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "16399:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "id": 5388,
+                                                                                        "name": "fsig",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5099,
+                                                                                        "src": "16404:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes4",
+                                                                                            "typeString": "bytes4"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "arguments": [
+                                                                                                    {
+                                                                                                        "id": 5392,
+                                                                                                        "name": "ins",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5112,
+                                                                                                        "src": "16437:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    {
+                                                                                                        "id": 5393,
+                                                                                                        "name": "field_depth",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5104,
+                                                                                                        "src": "16442:11:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    }
+                                                                                                ],
+                                                                                                "expression": {
+                                                                                                    "argumentTypes": [
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        },
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    ],
+                                                                                                    "expression": {
+                                                                                                        "id": 5390,
+                                                                                                        "name": "abi",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": -1,
+                                                                                                        "src": "16420:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_magic_abi",
+                                                                                                            "typeString": "abi"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    "id": 5391,
+                                                                                                    "isConstant": false,
+                                                                                                    "isLValue": false,
+                                                                                                    "isPure": true,
+                                                                                                    "lValueRequested": false,
+                                                                                                    "memberName": "encodePacked",
+                                                                                                    "nodeType": "MemberAccess",
+                                                                                                    "src": "16420:16:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5394,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": false,
+                                                                                                "isPure": false,
+                                                                                                "kind": "functionCall",
+                                                                                                "lValueRequested": false,
+                                                                                                "names": [],
+                                                                                                "nodeType": "FunctionCall",
+                                                                                                "src": "16420:34:6",
+                                                                                                "tryCall": false,
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5389,
+                                                                                            "name": "keccak256",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": -8,
+                                                                                            "src": "16410:9:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5395,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "functionCall",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16410:45:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "baseExpression": {
+                                                                                                    "id": 5398,
+                                                                                                    "name": "reads",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5186,
+                                                                                                    "src": "16465:5:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                        "typeString": "bytes32[] memory"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5400,
+                                                                                                "indexExpression": {
+                                                                                                    "id": 5399,
+                                                                                                    "name": "i",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5302,
+                                                                                                    "src": "16471:1:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_uint256",
+                                                                                                        "typeString": "uint256"
+                                                                                                    }
+                                                                                                },
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "nodeType": "IndexAccess",
+                                                                                                "src": "16465:8:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                                    "typeString": "bytes32"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5397,
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": false,
+                                                                                            "isPure": true,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                                            "src": "16457:7:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                                "typeString": "type(uint256)"
+                                                                                            },
+                                                                                            "typeName": {
+                                                                                                "id": 5396,
+                                                                                                "name": "uint256",
+                                                                                                "nodeType": "ElementaryTypeName",
+                                                                                                "src": "16457:7:6",
+                                                                                                "typeDescriptions": {}
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5401,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "typeConversion",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16457:17:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes4",
+                                                                                            "typeString": "bytes4"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_uint256",
+                                                                                            "typeString": "uint256"
+                                                                                        }
+                                                                                    ],
+                                                                                    "id": 5386,
+                                                                                    "name": "SlotFound",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5043,
+                                                                                    "src": "16389:9:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_bytes4_$_t_bytes32_$_t_uint256_$returns$__$",
+                                                                                        "typeString": "function (address,bytes4,bytes32,uint256)"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5402,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16389:86:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                                    "typeString": "tuple()"
+                                                                                }
+                                                                            },
+                                                                            "id": 5403,
+                                                                            "nodeType": "EmitStatement",
+                                                                            "src": "16384:91:6"
+                                                                        },
+                                                                        {
+                                                                            "expression": {
+                                                                                "id": 5425,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": false,
+                                                                                "leftHandSide": {
+                                                                                    "baseExpression": {
+                                                                                        "baseExpression": {
+                                                                                            "baseExpression": {
+                                                                                                "expression": {
+                                                                                                    "id": 5404,
+                                                                                                    "name": "self",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5088,
+                                                                                                    "src": "16497:4:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5415,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "memberName": "slots",
+                                                                                                "nodeType": "MemberAccess",
+                                                                                                "referencedDeclaration": 5013,
+                                                                                                "src": "16497:10:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                                                    "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                                                                }
+                                                                                            },
+                                                                                            "id": 5416,
+                                                                                            "indexExpression": {
+                                                                                                "id": 5406,
+                                                                                                "name": "who",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5094,
+                                                                                                "src": "16508:3:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_address",
+                                                                                                    "typeString": "address"
+                                                                                                }
+                                                                                            },
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": true,
+                                                                                            "isPure": false,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "IndexAccess",
+                                                                                            "src": "16497:15:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                                                                "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5417,
+                                                                                        "indexExpression": {
+                                                                                            "id": 5407,
+                                                                                            "name": "fsig",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5099,
+                                                                                            "src": "16513:4:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_bytes4",
+                                                                                                "typeString": "bytes4"
+                                                                                            }
+                                                                                        },
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": true,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "IndexAccess",
+                                                                                        "src": "16497:21:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                                                            "typeString": "mapping(bytes32 => uint256)"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5418,
+                                                                                    "indexExpression": {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "arguments": [
+                                                                                                    {
+                                                                                                        "id": 5411,
+                                                                                                        "name": "ins",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5112,
+                                                                                                        "src": "16546:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    {
+                                                                                                        "id": 5412,
+                                                                                                        "name": "field_depth",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5104,
+                                                                                                        "src": "16551:11:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    }
+                                                                                                ],
+                                                                                                "expression": {
+                                                                                                    "argumentTypes": [
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        },
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    ],
+                                                                                                    "expression": {
+                                                                                                        "id": 5409,
+                                                                                                        "name": "abi",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": -1,
+                                                                                                        "src": "16529:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_magic_abi",
+                                                                                                            "typeString": "abi"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    "id": 5410,
+                                                                                                    "isConstant": false,
+                                                                                                    "isLValue": false,
+                                                                                                    "isPure": true,
+                                                                                                    "lValueRequested": false,
+                                                                                                    "memberName": "encodePacked",
+                                                                                                    "nodeType": "MemberAccess",
+                                                                                                    "src": "16529:16:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5413,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": false,
+                                                                                                "isPure": false,
+                                                                                                "kind": "functionCall",
+                                                                                                "lValueRequested": false,
+                                                                                                "names": [],
+                                                                                                "nodeType": "FunctionCall",
+                                                                                                "src": "16529:34:6",
+                                                                                                "tryCall": false,
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5408,
+                                                                                            "name": "keccak256",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": -8,
+                                                                                            "src": "16519:9:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5414,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "functionCall",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16519:45:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": true,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": true,
+                                                                                    "nodeType": "IndexAccess",
+                                                                                    "src": "16497:68:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_uint256",
+                                                                                        "typeString": "uint256"
+                                                                                    }
+                                                                                },
+                                                                                "nodeType": "Assignment",
+                                                                                "operator": "=",
+                                                                                "rightHandSide": {
+                                                                                    "arguments": [
+                                                                                        {
+                                                                                            "baseExpression": {
+                                                                                                "id": 5421,
+                                                                                                "name": "reads",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5186,
+                                                                                                "src": "16576:5:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                    "typeString": "bytes32[] memory"
+                                                                                                }
+                                                                                            },
+                                                                                            "id": 5423,
+                                                                                            "indexExpression": {
+                                                                                                "id": 5422,
+                                                                                                "name": "i",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5302,
+                                                                                                "src": "16582:1:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_uint256",
+                                                                                                    "typeString": "uint256"
+                                                                                                }
+                                                                                            },
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": true,
+                                                                                            "isPure": false,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "IndexAccess",
+                                                                                            "src": "16576:8:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_bytes32",
+                                                                                                "typeString": "bytes32"
+                                                                                            }
+                                                                                        }
+                                                                                    ],
+                                                                                    "expression": {
+                                                                                        "argumentTypes": [
+                                                                                            {
+                                                                                                "typeIdentifier": "t_bytes32",
+                                                                                                "typeString": "bytes32"
+                                                                                            }
+                                                                                        ],
+                                                                                        "id": 5420,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": true,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "ElementaryTypeNameExpression",
+                                                                                        "src": "16568:7:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                            "typeString": "type(uint256)"
+                                                                                        },
+                                                                                        "typeName": {
+                                                                                            "id": 5419,
+                                                                                            "name": "uint256",
+                                                                                            "nodeType": "ElementaryTypeName",
+                                                                                            "src": "16568:7:6",
+                                                                                            "typeDescriptions": {}
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5424,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": false,
+                                                                                    "kind": "typeConversion",
+                                                                                    "lValueRequested": false,
+                                                                                    "names": [],
+                                                                                    "nodeType": "FunctionCall",
+                                                                                    "src": "16568:17:6",
+                                                                                    "tryCall": false,
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_uint256",
+                                                                                        "typeString": "uint256"
+                                                                                    }
+                                                                                },
+                                                                                "src": "16497:88:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "id": 5426,
+                                                                            "nodeType": "ExpressionStatement",
+                                                                            "src": "16497:88:6"
+                                                                        },
+                                                                        {
+                                                                            "expression": {
+                                                                                "id": 5443,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": false,
+                                                                                "leftHandSide": {
+                                                                                    "baseExpression": {
+                                                                                        "baseExpression": {
+                                                                                            "baseExpression": {
+                                                                                                "expression": {
+                                                                                                    "id": 5427,
+                                                                                                    "name": "self",
+                                                                                                    "nodeType": "Identifier",
+                                                                                                    "overloadedDeclarations": [],
+                                                                                                    "referencedDeclaration": 5088,
+                                                                                                    "src": "16607:4:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                                                        "typeString": "struct StdStorage storage pointer"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5438,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": true,
+                                                                                                "isPure": false,
+                                                                                                "lValueRequested": false,
+                                                                                                "memberName": "finds",
+                                                                                                "nodeType": "MemberAccess",
+                                                                                                "referencedDeclaration": 5021,
+                                                                                                "src": "16607:10:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                                                                    "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                                                                }
+                                                                                            },
+                                                                                            "id": 5439,
+                                                                                            "indexExpression": {
+                                                                                                "id": 5429,
+                                                                                                "name": "who",
+                                                                                                "nodeType": "Identifier",
+                                                                                                "overloadedDeclarations": [],
+                                                                                                "referencedDeclaration": 5094,
+                                                                                                "src": "16618:3:6",
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_address",
+                                                                                                    "typeString": "address"
+                                                                                                }
+                                                                                            },
+                                                                                            "isConstant": false,
+                                                                                            "isLValue": true,
+                                                                                            "isPure": false,
+                                                                                            "lValueRequested": false,
+                                                                                            "nodeType": "IndexAccess",
+                                                                                            "src": "16607:15:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                                                                "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5440,
+                                                                                        "indexExpression": {
+                                                                                            "id": 5430,
+                                                                                            "name": "fsig",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5099,
+                                                                                            "src": "16623:4:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_bytes4",
+                                                                                                "typeString": "bytes4"
+                                                                                            }
+                                                                                        },
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": true,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "IndexAccess",
+                                                                                        "src": "16607:21:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                                                            "typeString": "mapping(bytes32 => bool)"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5441,
+                                                                                    "indexExpression": {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "arguments": [
+                                                                                                    {
+                                                                                                        "id": 5434,
+                                                                                                        "name": "ins",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5112,
+                                                                                                        "src": "16656:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    {
+                                                                                                        "id": 5435,
+                                                                                                        "name": "field_depth",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": 5104,
+                                                                                                        "src": "16661:11:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    }
+                                                                                                ],
+                                                                                                "expression": {
+                                                                                                    "argumentTypes": [
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                            "typeString": "bytes32[] memory"
+                                                                                                        },
+                                                                                                        {
+                                                                                                            "typeIdentifier": "t_uint256",
+                                                                                                            "typeString": "uint256"
+                                                                                                        }
+                                                                                                    ],
+                                                                                                    "expression": {
+                                                                                                        "id": 5432,
+                                                                                                        "name": "abi",
+                                                                                                        "nodeType": "Identifier",
+                                                                                                        "overloadedDeclarations": [],
+                                                                                                        "referencedDeclaration": -1,
+                                                                                                        "src": "16639:3:6",
+                                                                                                        "typeDescriptions": {
+                                                                                                            "typeIdentifier": "t_magic_abi",
+                                                                                                            "typeString": "abi"
+                                                                                                        }
+                                                                                                    },
+                                                                                                    "id": 5433,
+                                                                                                    "isConstant": false,
+                                                                                                    "isLValue": false,
+                                                                                                    "isPure": true,
+                                                                                                    "lValueRequested": false,
+                                                                                                    "memberName": "encodePacked",
+                                                                                                    "nodeType": "MemberAccess",
+                                                                                                    "src": "16639:16:6",
+                                                                                                    "typeDescriptions": {
+                                                                                                        "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                                                        "typeString": "function () pure returns (bytes memory)"
+                                                                                                    }
+                                                                                                },
+                                                                                                "id": 5436,
+                                                                                                "isConstant": false,
+                                                                                                "isLValue": false,
+                                                                                                "isPure": false,
+                                                                                                "kind": "functionCall",
+                                                                                                "lValueRequested": false,
+                                                                                                "names": [],
+                                                                                                "nodeType": "FunctionCall",
+                                                                                                "src": "16639:34:6",
+                                                                                                "tryCall": false,
+                                                                                                "typeDescriptions": {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            }
+                                                                                        ],
+                                                                                        "expression": {
+                                                                                            "argumentTypes": [
+                                                                                                {
+                                                                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                                    "typeString": "bytes memory"
+                                                                                                }
+                                                                                            ],
+                                                                                            "id": 5431,
+                                                                                            "name": "keccak256",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": -8,
+                                                                                            "src": "16629:9:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                                                "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5437,
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": false,
+                                                                                        "isPure": false,
+                                                                                        "kind": "functionCall",
+                                                                                        "lValueRequested": false,
+                                                                                        "names": [],
+                                                                                        "nodeType": "FunctionCall",
+                                                                                        "src": "16629:45:6",
+                                                                                        "tryCall": false,
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": true,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": true,
+                                                                                    "nodeType": "IndexAccess",
+                                                                                    "src": "16607:68:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_bool",
+                                                                                        "typeString": "bool"
+                                                                                    }
+                                                                                },
+                                                                                "nodeType": "Assignment",
+                                                                                "operator": "=",
+                                                                                "rightHandSide": {
+                                                                                    "hexValue": "74727565",
+                                                                                    "id": 5442,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "bool",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "16678:4:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_bool",
+                                                                                        "typeString": "bool"
+                                                                                    },
+                                                                                    "value": "true"
+                                                                                },
+                                                                                "src": "16607:75:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bool",
+                                                                                    "typeString": "bool"
+                                                                                }
+                                                                            },
+                                                                            "id": 5444,
+                                                                            "nodeType": "ExpressionStatement",
+                                                                            "src": "16607:75:6"
+                                                                        },
+                                                                        {
+                                                                            "expression": {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "id": 5448,
+                                                                                        "name": "who",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5094,
+                                                                                        "src": "16723:3:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "baseExpression": {
+                                                                                            "id": 5449,
+                                                                                            "name": "reads",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5186,
+                                                                                            "src": "16728:5:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                                "typeString": "bytes32[] memory"
+                                                                                            }
+                                                                                        },
+                                                                                        "id": 5451,
+                                                                                        "indexExpression": {
+                                                                                            "id": 5450,
+                                                                                            "name": "i",
+                                                                                            "nodeType": "Identifier",
+                                                                                            "overloadedDeclarations": [],
+                                                                                            "referencedDeclaration": 5302,
+                                                                                            "src": "16734:1:6",
+                                                                                            "typeDescriptions": {
+                                                                                                "typeIdentifier": "t_uint256",
+                                                                                                "typeString": "uint256"
+                                                                                            }
+                                                                                        },
+                                                                                        "isConstant": false,
+                                                                                        "isLValue": true,
+                                                                                        "isPure": false,
+                                                                                        "lValueRequested": false,
+                                                                                        "nodeType": "IndexAccess",
+                                                                                        "src": "16728:8:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    },
+                                                                                    {
+                                                                                        "id": 5452,
+                                                                                        "name": "prev",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5313,
+                                                                                        "src": "16738:4:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    }
+                                                                                ],
+                                                                                "expression": {
+                                                                                    "argumentTypes": [
+                                                                                        {
+                                                                                            "typeIdentifier": "t_address",
+                                                                                            "typeString": "address"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        },
+                                                                                        {
+                                                                                            "typeIdentifier": "t_bytes32",
+                                                                                            "typeString": "bytes32"
+                                                                                        }
+                                                                                    ],
+                                                                                    "expression": {
+                                                                                        "id": 5445,
+                                                                                        "name": "vm_std_store",
+                                                                                        "nodeType": "Identifier",
+                                                                                        "overloadedDeclarations": [],
+                                                                                        "referencedDeclaration": 5066,
+                                                                                        "src": "16704:12:6",
+                                                                                        "typeDescriptions": {
+                                                                                            "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                            "typeString": "contract Vm"
+                                                                                        }
+                                                                                    },
+                                                                                    "id": 5447,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": false,
+                                                                                    "lValueRequested": false,
+                                                                                    "memberName": "store",
+                                                                                    "nodeType": "MemberAccess",
+                                                                                    "referencedDeclaration": 6031,
+                                                                                    "src": "16704:18:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                                                        "typeString": "function (address,bytes32,bytes32) external"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5453,
+                                                                                "isConstant": false,
+                                                                                "isLValue": false,
+                                                                                "isPure": false,
+                                                                                "kind": "functionCall",
+                                                                                "lValueRequested": false,
+                                                                                "names": [],
+                                                                                "nodeType": "FunctionCall",
+                                                                                "src": "16704:39:6",
+                                                                                "tryCall": false,
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                                    "typeString": "tuple()"
+                                                                                }
+                                                                            },
+                                                                            "id": 5454,
+                                                                            "nodeType": "ExpressionStatement",
+                                                                            "src": "16704:39:6"
+                                                                        },
+                                                                        {
+                                                                            "id": 5455,
+                                                                            "nodeType": "Break",
+                                                                            "src": "16765:5:6"
+                                                                        }
+                                                                    ]
+                                                                }
+                                                            },
+                                                            {
+                                                                "expression": {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5461,
+                                                                            "name": "who",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5094,
+                                                                            "src": "16825:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "baseExpression": {
+                                                                                "id": 5462,
+                                                                                "name": "reads",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5186,
+                                                                                "src": "16830:5:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                    "typeString": "bytes32[] memory"
+                                                                                }
+                                                                            },
+                                                                            "id": 5464,
+                                                                            "indexExpression": {
+                                                                                "id": 5463,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5302,
+                                                                                "src": "16836:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "isConstant": false,
+                                                                            "isLValue": true,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "IndexAccess",
+                                                                            "src": "16830:8:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5465,
+                                                                            "name": "prev",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5313,
+                                                                            "src": "16840:4:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_address",
+                                                                                "typeString": "address"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_bytes32",
+                                                                                "typeString": "bytes32"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5458,
+                                                                            "name": "vm_std_store",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5066,
+                                                                            "src": "16806:12:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                                "typeString": "contract Vm"
+                                                                            }
+                                                                        },
+                                                                        "id": 5460,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "store",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "referencedDeclaration": 6031,
+                                                                        "src": "16806:18:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                                            "typeString": "function (address,bytes32,bytes32) external"
+                                                                        }
+                                                                    },
+                                                                    "id": 5466,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "16806:39:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_tuple$__$",
+                                                                        "typeString": "tuple()"
+                                                                    }
+                                                                },
+                                                                "id": 5467,
+                                                                "nodeType": "ExpressionStatement",
+                                                                "src": "16806:39:6"
+                                                            }
+                                                        ]
+                                                    },
+                                                    "condition": {
+                                                        "commonType": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        },
+                                                        "id": 5308,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "leftExpression": {
+                                                            "id": 5305,
+                                                            "name": "i",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5302,
+                                                            "src": "15690:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "nodeType": "BinaryOperation",
+                                                        "operator": "<",
+                                                        "rightExpression": {
+                                                            "expression": {
+                                                                "id": 5306,
+                                                                "name": "reads",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5186,
+                                                                "src": "15694:5:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                }
+                                                            },
+                                                            "id": 5307,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "length",
+                                                            "nodeType": "MemberAccess",
+                                                            "src": "15694:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "src": "15690:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "id": 5469,
+                                                    "initializationExpression": {
+                                                        "assignments": [5302],
+                                                        "declarations": [
+                                                            {
+                                                                "constant": false,
+                                                                "id": 5302,
+                                                                "mutability": "mutable",
+                                                                "name": "i",
+                                                                "nameLocation": "15683:1:6",
+                                                                "nodeType": "VariableDeclaration",
+                                                                "scope": 5469,
+                                                                "src": "15675:9:6",
+                                                                "stateVariable": false,
+                                                                "storageLocation": "default",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 5301,
+                                                                    "name": "uint256",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "15675:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                },
+                                                                "visibility": "internal"
+                                                            }
+                                                        ],
+                                                        "id": 5304,
+                                                        "initialValue": {
+                                                            "hexValue": "30",
+                                                            "id": 5303,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "number",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "15687:1:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_rational_0_by_1",
+                                                                "typeString": "int_const 0"
+                                                            },
+                                                            "value": "0"
+                                                        },
+                                                        "nodeType": "VariableDeclarationStatement",
+                                                        "src": "15675:13:6"
+                                                    },
+                                                    "loopExpression": {
+                                                        "expression": {
+                                                            "id": 5310,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "UnaryOperation",
+                                                            "operator": "++",
+                                                            "prefix": false,
+                                                            "src": "15708:3:6",
+                                                            "subExpression": {
+                                                                "id": 5309,
+                                                                "name": "i",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5302,
+                                                                "src": "15708:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "id": 5311,
+                                                        "nodeType": "ExpressionStatement",
+                                                        "src": "15708:3:6"
+                                                    },
+                                                    "nodeType": "ForStatement",
+                                                    "src": "15670:1190:6"
+                                                }
+                                            ]
+                                        }
+                                    },
+                                    "id": 5478,
+                                    "nodeType": "IfStatement",
+                                    "src": "14956:1997:6",
+                                    "trueBody": {
+                                        "id": 5296,
+                                        "nodeType": "Block",
+                                        "src": "14979:649:6",
+                                        "statements": [
+                                            {
+                                                "assignments": [5200],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 5200,
+                                                        "mutability": "mutable",
+                                                        "name": "curr",
+                                                        "nameLocation": "15001:4:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 5296,
+                                                        "src": "14993:12:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 5199,
+                                                            "name": "bytes32",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "14993:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 5208,
+                                                "initialValue": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5203,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5094,
+                                                            "src": "15026:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        {
+                                                            "baseExpression": {
+                                                                "id": 5204,
+                                                                "name": "reads",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5186,
+                                                                "src": "15031:5:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                }
+                                                            },
+                                                            "id": 5206,
+                                                            "indexExpression": {
+                                                                "hexValue": "30",
+                                                                "id": 5205,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "15037:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                    "typeString": "int_const 0"
+                                                                },
+                                                                "value": "0"
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "15031:8:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 5201,
+                                                            "name": "vm_std_store",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5066,
+                                                            "src": "15008:12:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_contract$_Vm_$6200",
+                                                                "typeString": "contract Vm"
+                                                            }
+                                                        },
+                                                        "id": 5202,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "load",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 6022,
+                                                        "src": "15008:17:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$returns$_t_bytes32_$",
+                                                            "typeString": "function (address,bytes32) external returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5207,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "15008:32:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "14993:47:6"
+                                            },
+                                            {
+                                                "condition": {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    },
+                                                    "id": 5214,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "id": 5209,
+                                                        "name": "curr",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5200,
+                                                        "src": "15058:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "==",
+                                                    "rightExpression": {
+                                                        "arguments": [
+                                                            {
+                                                                "hexValue": "30",
+                                                                "id": 5212,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "15074:1:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                    "typeString": "int_const 0"
+                                                                },
+                                                                "value": "0"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_rational_0_by_1",
+                                                                    "typeString": "int_const 0"
+                                                                }
+                                                            ],
+                                                            "id": 5211,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "15066:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                "typeString": "type(bytes32)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5210,
+                                                                "name": "bytes32",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "15066:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5213,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "15066:10:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "src": "15058:18:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 5226,
+                                                "nodeType": "IfStatement",
+                                                "src": "15054:106:6",
+                                                "trueBody": {
+                                                    "id": 5225,
+                                                    "nodeType": "Block",
+                                                    "src": "15078:82:6",
+                                                    "statements": [
+                                                        {
+                                                            "eventCall": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5216,
+                                                                        "name": "who",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5094,
+                                                                        "src": "15122:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    },
+                                                                    {
+                                                                        "arguments": [
+                                                                            {
+                                                                                "baseExpression": {
+                                                                                    "id": 5219,
+                                                                                    "name": "reads",
+                                                                                    "nodeType": "Identifier",
+                                                                                    "overloadedDeclarations": [],
+                                                                                    "referencedDeclaration": 5186,
+                                                                                    "src": "15135:5:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                        "typeString": "bytes32[] memory"
+                                                                                    }
+                                                                                },
+                                                                                "id": 5221,
+                                                                                "indexExpression": {
+                                                                                    "hexValue": "30",
+                                                                                    "id": 5220,
+                                                                                    "isConstant": false,
+                                                                                    "isLValue": false,
+                                                                                    "isPure": true,
+                                                                                    "kind": "number",
+                                                                                    "lValueRequested": false,
+                                                                                    "nodeType": "Literal",
+                                                                                    "src": "15141:1:6",
+                                                                                    "typeDescriptions": {
+                                                                                        "typeIdentifier": "t_rational_0_by_1",
+                                                                                        "typeString": "int_const 0"
+                                                                                    },
+                                                                                    "value": "0"
+                                                                                },
+                                                                                "isConstant": false,
+                                                                                "isLValue": true,
+                                                                                "isPure": false,
+                                                                                "lValueRequested": false,
+                                                                                "nodeType": "IndexAccess",
+                                                                                "src": "15135:8:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "argumentTypes": [
+                                                                                {
+                                                                                    "typeIdentifier": "t_bytes32",
+                                                                                    "typeString": "bytes32"
+                                                                                }
+                                                                            ],
+                                                                            "id": 5218,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": true,
+                                                                            "lValueRequested": false,
+                                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                                            "src": "15127:7:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                                "typeString": "type(uint256)"
+                                                                            },
+                                                                            "typeName": {
+                                                                                "id": 5217,
+                                                                                "name": "uint256",
+                                                                                "nodeType": "ElementaryTypeName",
+                                                                                "src": "15127:7:6",
+                                                                                "typeDescriptions": {}
+                                                                            }
+                                                                        },
+                                                                        "id": 5222,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": false,
+                                                                        "kind": "typeConversion",
+                                                                        "lValueRequested": false,
+                                                                        "names": [],
+                                                                        "nodeType": "FunctionCall",
+                                                                        "src": "15127:17:6",
+                                                                        "tryCall": false,
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        },
+                                                                        {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    ],
+                                                                    "id": 5215,
+                                                                    "name": "WARNING_UninitedSlot",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5049,
+                                                                    "src": "15101:20:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_uint256_$returns$__$",
+                                                                        "typeString": "function (address,uint256)"
+                                                                    }
+                                                                },
+                                                                "id": 5223,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "15101:44:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                    "typeString": "tuple()"
+                                                                }
+                                                            },
+                                                            "id": 5224,
+                                                            "nodeType": "EmitStatement",
+                                                            "src": "15096:49:6"
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                "condition": {
+                                                    "commonType": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    },
+                                                    "id": 5229,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftExpression": {
+                                                        "id": 5227,
+                                                        "name": "fdat",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5163,
+                                                        "src": "15177:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "nodeType": "BinaryOperation",
+                                                    "operator": "!=",
+                                                    "rightExpression": {
+                                                        "id": 5228,
+                                                        "name": "curr",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5200,
+                                                        "src": "15185:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "src": "15177:12:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 5236,
+                                                "nodeType": "IfStatement",
+                                                "src": "15173:149:6",
+                                                "trueBody": {
+                                                    "id": 5235,
+                                                    "nodeType": "Block",
+                                                    "src": "15191:131:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "hexValue": "66616c7365",
+                                                                        "id": 5231,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "bool",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "15217:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        },
+                                                                        "value": "false"
+                                                                    },
+                                                                    {
+                                                                        "hexValue": "5061636b656420736c6f742e205468697320776f756c642063617573652064616e6765726f7573206f76657277726974696e6720616e642063757272656e746c792069736e7420737570706f72746564",
+                                                                        "id": 5232,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "string",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "15224:82:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                            "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                                        },
+                                                                        "value": "Packed slot. This would cause dangerous overwriting and currently isnt supported"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_bool",
+                                                                            "typeString": "bool"
+                                                                        },
+                                                                        {
+                                                                            "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                            "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                                        }
+                                                                    ],
+                                                                    "id": 5230,
+                                                                    "name": "require",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [
+                                                                        -18, -18
+                                                                    ],
+                                                                    "referencedDeclaration": -18,
+                                                                    "src": "15209:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                                        "typeString": "function (bool,string memory) pure"
+                                                                    }
+                                                                },
+                                                                "id": 5233,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "functionCall",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "15209:98:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_tuple$__$",
+                                                                    "typeString": "tuple()"
+                                                                }
+                                                            },
+                                                            "id": 5234,
+                                                            "nodeType": "ExpressionStatement",
+                                                            "src": "15209:98:6"
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                "eventCall": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5238,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5094,
+                                                            "src": "15350:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        {
+                                                            "id": 5239,
+                                                            "name": "fsig",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5099,
+                                                            "src": "15355:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes4",
+                                                                "typeString": "bytes4"
+                                                            }
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5243,
+                                                                            "name": "ins",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5112,
+                                                                            "src": "15388:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5244,
+                                                                            "name": "field_depth",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5104,
+                                                                            "src": "15393:11:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5241,
+                                                                            "name": "abi",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": -1,
+                                                                            "src": "15371:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_magic_abi",
+                                                                                "typeString": "abi"
+                                                                            }
+                                                                        },
+                                                                        "id": 5242,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "encodePacked",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "src": "15371:16:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                            "typeString": "function () pure returns (bytes memory)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5245,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15371:34:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                ],
+                                                                "id": 5240,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "15361:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5246,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15361:45:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "baseExpression": {
+                                                                        "id": 5249,
+                                                                        "name": "reads",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5186,
+                                                                        "src": "15416:5:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                            "typeString": "bytes32[] memory"
+                                                                        }
+                                                                    },
+                                                                    "id": 5251,
+                                                                    "indexExpression": {
+                                                                        "hexValue": "30",
+                                                                        "id": 5250,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "number",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "15422:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_rational_0_by_1",
+                                                                            "typeString": "int_const 0"
+                                                                        },
+                                                                        "value": "0"
+                                                                    },
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "IndexAccess",
+                                                                    "src": "15416:8:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes32",
+                                                                        "typeString": "bytes32"
+                                                                    }
+                                                                ],
+                                                                "id": 5248,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "15408:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_uint256_$",
+                                                                    "typeString": "type(uint256)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 5247,
+                                                                    "name": "uint256",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "15408:7:6",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 5252,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15408:17:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes4",
+                                                                "typeString": "bytes4"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 5237,
+                                                        "name": "SlotFound",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5043,
+                                                        "src": "15340:9:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_bytes4_$_t_bytes32_$_t_uint256_$returns$__$",
+                                                            "typeString": "function (address,bytes4,bytes32,uint256)"
+                                                        }
+                                                    },
+                                                    "id": 5253,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "15340:86:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 5254,
+                                                "nodeType": "EmitStatement",
+                                                "src": "15335:91:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 5276,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "baseExpression": {
+                                                            "baseExpression": {
+                                                                "baseExpression": {
+                                                                    "expression": {
+                                                                        "id": 5255,
+                                                                        "name": "self",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5088,
+                                                                        "src": "15440:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                            "typeString": "struct StdStorage storage pointer"
+                                                                        }
+                                                                    },
+                                                                    "id": 5266,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "slots",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5013,
+                                                                    "src": "15440:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                                    }
+                                                                },
+                                                                "id": 5267,
+                                                                "indexExpression": {
+                                                                    "id": 5257,
+                                                                    "name": "who",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5094,
+                                                                    "src": "15451:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                },
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "IndexAccess",
+                                                                "src": "15440:15:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                                }
+                                                            },
+                                                            "id": 5268,
+                                                            "indexExpression": {
+                                                                "id": 5258,
+                                                                "name": "fsig",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5099,
+                                                                "src": "15456:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes4",
+                                                                    "typeString": "bytes4"
+                                                                }
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "15440:21:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                                "typeString": "mapping(bytes32 => uint256)"
+                                                            }
+                                                        },
+                                                        "id": 5269,
+                                                        "indexExpression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5262,
+                                                                            "name": "ins",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5112,
+                                                                            "src": "15489:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5263,
+                                                                            "name": "field_depth",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5104,
+                                                                            "src": "15494:11:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5260,
+                                                                            "name": "abi",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": -1,
+                                                                            "src": "15472:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_magic_abi",
+                                                                                "typeString": "abi"
+                                                                            }
+                                                                        },
+                                                                        "id": 5261,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "encodePacked",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "src": "15472:16:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                            "typeString": "function () pure returns (bytes memory)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5264,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15472:34:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                ],
+                                                                "id": 5259,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "15462:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5265,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15462:45:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "15440:68:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "arguments": [
+                                                            {
+                                                                "baseExpression": {
+                                                                    "id": 5272,
+                                                                    "name": "reads",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5186,
+                                                                    "src": "15519:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    }
+                                                                },
+                                                                "id": 5274,
+                                                                "indexExpression": {
+                                                                    "hexValue": "30",
+                                                                    "id": 5273,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "kind": "number",
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "Literal",
+                                                                    "src": "15525:1:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_rational_0_by_1",
+                                                                        "typeString": "int_const 0"
+                                                                    },
+                                                                    "value": "0"
+                                                                },
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "IndexAccess",
+                                                                "src": "15519:8:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes32",
+                                                                    "typeString": "bytes32"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_bytes32",
+                                                                    "typeString": "bytes32"
+                                                                }
+                                                            ],
+                                                            "id": 5271,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "15511:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5270,
+                                                                "name": "uint256",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "15511:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5275,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "15511:17:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "src": "15440:88:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 5277,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "15440:88:6"
+                                            },
+                                            {
+                                                "expression": {
+                                                    "id": 5294,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "baseExpression": {
+                                                            "baseExpression": {
+                                                                "baseExpression": {
+                                                                    "expression": {
+                                                                        "id": 5278,
+                                                                        "name": "self",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5088,
+                                                                        "src": "15542:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                            "typeString": "struct StdStorage storage pointer"
+                                                                        }
+                                                                    },
+                                                                    "id": 5289,
+                                                                    "isConstant": false,
+                                                                    "isLValue": true,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "memberName": "finds",
+                                                                    "nodeType": "MemberAccess",
+                                                                    "referencedDeclaration": 5021,
+                                                                    "src": "15542:10:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                                    }
+                                                                },
+                                                                "id": 5290,
+                                                                "indexExpression": {
+                                                                    "id": 5280,
+                                                                    "name": "who",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5094,
+                                                                    "src": "15553:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_address",
+                                                                        "typeString": "address"
+                                                                    }
+                                                                },
+                                                                "isConstant": false,
+                                                                "isLValue": true,
+                                                                "isPure": false,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "IndexAccess",
+                                                                "src": "15542:15:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                                }
+                                                            },
+                                                            "id": 5291,
+                                                            "indexExpression": {
+                                                                "id": 5281,
+                                                                "name": "fsig",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5099,
+                                                                "src": "15558:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_bytes4",
+                                                                    "typeString": "bytes4"
+                                                                }
+                                                            },
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "IndexAccess",
+                                                            "src": "15542:21:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                                "typeString": "mapping(bytes32 => bool)"
+                                                            }
+                                                        },
+                                                        "id": 5292,
+                                                        "indexExpression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "arguments": [
+                                                                        {
+                                                                            "id": 5285,
+                                                                            "name": "ins",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5112,
+                                                                            "src": "15591:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            }
+                                                                        },
+                                                                        {
+                                                                            "id": 5286,
+                                                                            "name": "field_depth",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5104,
+                                                                            "src": "15596:11:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        }
+                                                                    ],
+                                                                    "expression": {
+                                                                        "argumentTypes": [
+                                                                            {
+                                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                                "typeString": "bytes32[] memory"
+                                                                            },
+                                                                            {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        ],
+                                                                        "expression": {
+                                                                            "id": 5283,
+                                                                            "name": "abi",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": -1,
+                                                                            "src": "15574:3:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_magic_abi",
+                                                                                "typeString": "abi"
+                                                                            }
+                                                                        },
+                                                                        "id": 5284,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "lValueRequested": false,
+                                                                        "memberName": "encodePacked",
+                                                                        "nodeType": "MemberAccess",
+                                                                        "src": "15574:16:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                            "typeString": "function () pure returns (bytes memory)"
+                                                                        }
+                                                                    },
+                                                                    "id": 5287,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "kind": "functionCall",
+                                                                    "lValueRequested": false,
+                                                                    "names": [],
+                                                                    "nodeType": "FunctionCall",
+                                                                    "src": "15574:34:6",
+                                                                    "tryCall": false,
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                                        "typeString": "bytes memory"
+                                                                    }
+                                                                ],
+                                                                "id": 5282,
+                                                                "name": "keccak256",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -8,
+                                                                "src": "15564:9:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                                }
+                                                            },
+                                                            "id": 5288,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "15564:45:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": true,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "15542:68:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "=",
+                                                    "rightHandSide": {
+                                                        "hexValue": "74727565",
+                                                        "id": 5293,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "kind": "bool",
+                                                        "lValueRequested": false,
+                                                        "nodeType": "Literal",
+                                                        "src": "15613:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bool",
+                                                            "typeString": "bool"
+                                                        },
+                                                        "value": "true"
+                                                    },
+                                                    "src": "15542:75:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bool",
+                                                        "typeString": "bool"
+                                                    }
+                                                },
+                                                "id": 5295,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "15542:75:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "baseExpression": {
+                                                    "baseExpression": {
+                                                        "baseExpression": {
+                                                            "expression": {
+                                                                "id": 5480,
+                                                                "name": "self",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5088,
+                                                                "src": "16971:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 5481,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "finds",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5021,
+                                                            "src": "16971:10:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                            }
+                                                        },
+                                                        "id": 5483,
+                                                        "indexExpression": {
+                                                            "id": 5482,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5094,
+                                                            "src": "16982:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "16971:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                            "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                        }
+                                                    },
+                                                    "id": 5485,
+                                                    "indexExpression": {
+                                                        "id": 5484,
+                                                        "name": "fsig",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5099,
+                                                        "src": "16987:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes4",
+                                                            "typeString": "bytes4"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "16971:21:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                        "typeString": "mapping(bytes32 => bool)"
+                                                    }
+                                                },
+                                                "id": 5493,
+                                                "indexExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "id": 5489,
+                                                                    "name": "ins",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5112,
+                                                                    "src": "17020:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    }
+                                                                },
+                                                                {
+                                                                    "id": 5490,
+                                                                    "name": "field_depth",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5104,
+                                                                    "src": "17025:11:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    },
+                                                                    {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "id": 5487,
+                                                                    "name": "abi",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": -1,
+                                                                    "src": "17003:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_magic_abi",
+                                                                        "typeString": "abi"
+                                                                    }
+                                                                },
+                                                                "id": 5488,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "memberName": "encodePacked",
+                                                                "nodeType": "MemberAccess",
+                                                                "src": "17003:16:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                    "typeString": "function () pure returns (bytes memory)"
+                                                                }
+                                                            },
+                                                            "id": 5491,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "17003:34:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 5486,
+                                                        "name": "keccak256",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -8,
+                                                        "src": "16993:9:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5492,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "16993:45:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "16971:68:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                }
+                                            },
+                                            {
+                                                "hexValue": "4e6f74466f756e64",
+                                                "id": 5494,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "string",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "17041:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_stringliteral_a896e77af5e233b52f3d565f8bd98eec0ddb0e671485cda84d2cd93d51849a53",
+                                                    "typeString": "literal_string \"NotFound\""
+                                                },
+                                                "value": "NotFound"
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_stringliteral_a896e77af5e233b52f3d565f8bd98eec0ddb0e671485cda84d2cd93d51849a53",
+                                                    "typeString": "literal_string \"NotFound\""
+                                                }
+                                            ],
+                                            "id": 5479,
+                                            "name": "require",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                -18, -18
+                                            ],
+                                            "referencedDeclaration": -18,
+                                            "src": "16963:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                "typeString": "function (bool,string memory) pure"
+                                            }
+                                        },
+                                        "id": 5495,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "16963:89:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5496,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "16963:89:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5499,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17063:19:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5497,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17070:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5498,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_target",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5030,
+                                            "src": "17070:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5500,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17063:19:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5503,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17092:16:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5501,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17099:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5502,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "17099:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5504,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17092:16:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5507,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17118:17:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5505,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17125:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5506,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_keys",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5024,
+                                            "src": "17125:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                "typeString": "bytes32[] storage ref"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5508,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17118:17:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5511,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "17145:18:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5509,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5088,
+                                                "src": "17152:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5510,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_depth",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5028,
+                                            "src": "17152:11:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5512,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17145:18:6"
+                                },
+                                {
+                                    "expression": {
+                                        "baseExpression": {
+                                            "baseExpression": {
+                                                "baseExpression": {
+                                                    "expression": {
+                                                        "id": 5513,
+                                                        "name": "self",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5088,
+                                                        "src": "17181:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                            "typeString": "struct StdStorage storage pointer"
+                                                        }
+                                                    },
+                                                    "id": 5514,
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "slots",
+                                                    "nodeType": "MemberAccess",
+                                                    "referencedDeclaration": 5013,
+                                                    "src": "17181:10:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                        "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                    }
+                                                },
+                                                "id": 5516,
+                                                "indexExpression": {
+                                                    "id": 5515,
+                                                    "name": "who",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5094,
+                                                    "src": "17192:3:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_address",
+                                                        "typeString": "address"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "17181:15:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                    "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                }
+                                            },
+                                            "id": 5518,
+                                            "indexExpression": {
+                                                "id": 5517,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5099,
+                                                "src": "17197:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "IndexAccess",
+                                            "src": "17181:21:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                "typeString": "mapping(bytes32 => uint256)"
+                                            }
+                                        },
+                                        "id": 5526,
+                                        "indexExpression": {
+                                            "arguments": [
+                                                {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5522,
+                                                            "name": "ins",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5112,
+                                                            "src": "17230:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "id": 5523,
+                                                            "name": "field_depth",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5104,
+                                                            "src": "17235:11:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                "typeString": "bytes32[] memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "id": 5520,
+                                                            "name": "abi",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": -1,
+                                                            "src": "17213:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_magic_abi",
+                                                                "typeString": "abi"
+                                                            }
+                                                        },
+                                                        "id": 5521,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": true,
+                                                        "lValueRequested": false,
+                                                        "memberName": "encodePacked",
+                                                        "nodeType": "MemberAccess",
+                                                        "src": "17213:16:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                            "typeString": "function () pure returns (bytes memory)"
+                                                        }
+                                                    },
+                                                    "id": 5524,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "17213:34:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                ],
+                                                "id": 5519,
+                                                "name": "keccak256",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -8,
+                                                "src": "17203:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                    "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                }
+                                            },
+                                            "id": 5525,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "17203:45:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "IndexAccess",
+                                        "src": "17181:68:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5092,
+                                    "id": 5527,
+                                    "nodeType": "Return",
+                                    "src": "17174:75:6"
+                                }
+                            ]
+                        },
+                        "documentation": {
+                            "id": 5085,
+                            "nodeType": "StructuredDocumentation",
+                            "src": "13634:129:6",
+                            "text": "@notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against"
+                        },
+                        "id": 5529,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "find",
+                        "nameLocation": "14151:4:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5089,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5088,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "14184:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5529,
+                                    "src": "14165:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5087,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5086,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "14165:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "14165:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "14155:39:6"
+                        },
+                        "returnParameters": {
+                            "id": 5092,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5091,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5529,
+                                    "src": "14229:7:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5090,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "14229:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "14228:9:6"
+                        },
+                        "scope": 5990,
+                        "src": "14142:3114:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5548,
+                            "nodeType": "Block",
+                            "src": "17358:60:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5544,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5540,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5532,
+                                                "src": "17368:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5542,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_target",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5030,
+                                            "src": "17368:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 5543,
+                                            "name": "_target",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5534,
+                                            "src": "17383:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "src": "17368:22:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "id": 5545,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17368:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5546,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5532,
+                                        "src": "17407:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5539,
+                                    "id": 5547,
+                                    "nodeType": "Return",
+                                    "src": "17400:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5549,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "target",
+                        "nameLocation": "17271:6:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5535,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5532,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17297:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5549,
+                                    "src": "17278:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5531,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5530,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17278:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17278:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5534,
+                                    "mutability": "mutable",
+                                    "name": "_target",
+                                    "nameLocation": "17311:7:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5549,
+                                    "src": "17303:15:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5533,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17303:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17277:42:6"
+                        },
+                        "returnParameters": {
+                            "id": 5539,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5538,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5549,
+                                    "src": "17338:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5537,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5536,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17338:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17338:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17337:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17262:156:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5568,
+                            "nodeType": "Block",
+                            "src": "17513:54:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5564,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5560,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5552,
+                                                "src": "17523:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5562,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "17523:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 5563,
+                                            "name": "_sig",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5554,
+                                            "src": "17535:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "src": "17523:16:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "id": 5565,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17523:16:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5566,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5552,
+                                        "src": "17556:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5559,
+                                    "id": 5567,
+                                    "nodeType": "Return",
+                                    "src": "17549:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5569,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "sig",
+                        "nameLocation": "17433:3:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5555,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5552,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17456:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5569,
+                                    "src": "17437:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5551,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5550,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17437:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17437:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5554,
+                                    "mutability": "mutable",
+                                    "name": "_sig",
+                                    "nameLocation": "17469:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5569,
+                                    "src": "17462:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    },
+                                    "typeName": {
+                                        "id": 5553,
+                                        "name": "bytes4",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17462:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17436:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5559,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5558,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5569,
+                                    "src": "17493:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5557,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5556,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17493:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17493:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17492:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17424:143:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5590,
+                            "nodeType": "Block",
+                            "src": "17669:60:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5586,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5580,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5572,
+                                                "src": "17679:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5582,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "17679:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "arguments": [
+                                                {
+                                                    "id": 5584,
+                                                    "name": "_sig",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5574,
+                                                    "src": "17696:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_string_memory_ptr",
+                                                        "typeString": "string memory"
+                                                    }
+                                                }
+                                            ],
+                                            "expression": {
+                                                "argumentTypes": [
+                                                    {
+                                                        "typeIdentifier": "t_string_memory_ptr",
+                                                        "typeString": "string memory"
+                                                    }
+                                                ],
+                                                "id": 5583,
+                                                "name": "sigs",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5084,
+                                                "src": "17691:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_function_internal_pure$_t_string_memory_ptr_$returns$_t_bytes4_$",
+                                                    "typeString": "function (string memory) pure returns (bytes4)"
+                                                }
+                                            },
+                                            "id": 5585,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "kind": "functionCall",
+                                            "lValueRequested": false,
+                                            "names": [],
+                                            "nodeType": "FunctionCall",
+                                            "src": "17691:10:6",
+                                            "tryCall": false,
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "src": "17679:22:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "id": 5587,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17679:22:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5588,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5572,
+                                        "src": "17718:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5579,
+                                    "id": 5589,
+                                    "nodeType": "Return",
+                                    "src": "17711:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5591,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "sig",
+                        "nameLocation": "17582:3:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5575,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5572,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17605:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5591,
+                                    "src": "17586:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5571,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5570,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17586:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17586:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5574,
+                                    "mutability": "mutable",
+                                    "name": "_sig",
+                                    "nameLocation": "17625:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5591,
+                                    "src": "17611:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_memory_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 5573,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17611:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17585:45:6"
+                        },
+                        "returnParameters": {
+                            "id": 5579,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5578,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5591,
+                                    "src": "17649:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5577,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5576,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17649:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17649:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17648:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17573:156:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5621,
+                            "nodeType": "Block",
+                            "src": "17829:85:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5613,
+                                                                        "name": "who",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5596,
+                                                                        "src": "17879:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "id": 5612,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                                    "src": "17871:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_type$_t_uint160_$",
+                                                                        "typeString": "type(uint160)"
+                                                                    },
+                                                                    "typeName": {
+                                                                        "id": 5611,
+                                                                        "name": "uint160",
+                                                                        "nodeType": "ElementaryTypeName",
+                                                                        "src": "17871:7:6",
+                                                                        "typeDescriptions": {}
+                                                                    }
+                                                                },
+                                                                "id": 5614,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "typeConversion",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "17871:12:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            ],
+                                                            "id": 5610,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "17863:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5609,
+                                                                "name": "uint256",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "17863:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5615,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "17863:21:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5608,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "17855:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5607,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "17855:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5616,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "17855:30:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "expression": {
+                                                    "id": 5602,
+                                                    "name": "self",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5594,
+                                                    "src": "17839:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                        "typeString": "struct StdStorage storage pointer"
+                                                    }
+                                                },
+                                                "id": 5605,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "_keys",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5024,
+                                                "src": "17839:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                    "typeString": "bytes32[] storage ref"
+                                                }
+                                            },
+                                            "id": 5606,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "push",
+                                            "nodeType": "MemberAccess",
+                                            "src": "17839:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_arraypush_nonpayable$_t_array$_t_bytes32_$dyn_storage_ptr_$_t_bytes32_$returns$__$bound_to$_t_array$_t_bytes32_$dyn_storage_ptr_$",
+                                                "typeString": "function (bytes32[] storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5617,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "17839:47:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5618,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "17839:47:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5619,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5594,
+                                        "src": "17903:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5601,
+                                    "id": 5620,
+                                    "nodeType": "Return",
+                                    "src": "17896:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5622,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "with_key",
+                        "nameLocation": "17744:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5597,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5594,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17772:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5622,
+                                    "src": "17753:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5593,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5592,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17753:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17753:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5596,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "17786:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5622,
+                                    "src": "17778:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5595,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17778:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17752:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5601,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5600,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5622,
+                                    "src": "17809:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5599,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5598,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17809:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17809:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17808:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17735:179:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5646,
+                            "nodeType": "Block",
+                            "src": "18014:67:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5640,
+                                                        "name": "amt",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5627,
+                                                        "src": "18048:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5639,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "18040:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5638,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "18040:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5641,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "18040:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "expression": {
+                                                    "id": 5633,
+                                                    "name": "self",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5625,
+                                                    "src": "18024:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                        "typeString": "struct StdStorage storage pointer"
+                                                    }
+                                                },
+                                                "id": 5636,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "_keys",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5024,
+                                                "src": "18024:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                    "typeString": "bytes32[] storage ref"
+                                                }
+                                            },
+                                            "id": 5637,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "push",
+                                            "nodeType": "MemberAccess",
+                                            "src": "18024:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_arraypush_nonpayable$_t_array$_t_bytes32_$dyn_storage_ptr_$_t_bytes32_$returns$__$bound_to$_t_array$_t_bytes32_$dyn_storage_ptr_$",
+                                                "typeString": "function (bytes32[] storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5642,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18024:29:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5643,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18024:29:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5644,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5625,
+                                        "src": "18070:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5632,
+                                    "id": 5645,
+                                    "nodeType": "Return",
+                                    "src": "18063:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5647,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "with_key",
+                        "nameLocation": "17929:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5628,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5625,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "17957:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5647,
+                                    "src": "17938:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5624,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5623,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17938:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17938:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5627,
+                                    "mutability": "mutable",
+                                    "name": "amt",
+                                    "nameLocation": "17971:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5647,
+                                    "src": "17963:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5626,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "17963:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17937:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5632,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5631,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5647,
+                                    "src": "17994:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5630,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5629,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "17994:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "17994:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "17993:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "17920:161:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5668,
+                            "nodeType": "Block",
+                            "src": "18180:58:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5663,
+                                                "name": "key",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5652,
+                                                "src": "18206:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "expression": {
+                                                    "id": 5658,
+                                                    "name": "self",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5650,
+                                                    "src": "18190:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                        "typeString": "struct StdStorage storage pointer"
+                                                    }
+                                                },
+                                                "id": 5661,
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "_keys",
+                                                "nodeType": "MemberAccess",
+                                                "referencedDeclaration": 5024,
+                                                "src": "18190:10:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                    "typeString": "bytes32[] storage ref"
+                                                }
+                                            },
+                                            "id": 5662,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "push",
+                                            "nodeType": "MemberAccess",
+                                            "src": "18190:15:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_arraypush_nonpayable$_t_array$_t_bytes32_$dyn_storage_ptr_$_t_bytes32_$returns$__$bound_to$_t_array$_t_bytes32_$dyn_storage_ptr_$",
+                                                "typeString": "function (bytes32[] storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5664,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18190:20:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5665,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18190:20:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5666,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5650,
+                                        "src": "18227:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5657,
+                                    "id": 5667,
+                                    "nodeType": "Return",
+                                    "src": "18220:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5669,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "with_key",
+                        "nameLocation": "18095:8:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5653,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5650,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18123:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5669,
+                                    "src": "18104:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5649,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5648,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18104:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18104:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5652,
+                                    "mutability": "mutable",
+                                    "name": "key",
+                                    "nameLocation": "18137:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5669,
+                                    "src": "18129:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5651,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18129:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18103:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5657,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5656,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5669,
+                                    "src": "18160:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5655,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5654,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18160:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18160:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18159:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "18086:152:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5688,
+                            "nodeType": "Block",
+                            "src": "18338:58:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "id": 5684,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftHandSide": {
+                                            "expression": {
+                                                "id": 5680,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5672,
+                                                "src": "18348:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5682,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_depth",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5028,
+                                            "src": "18348:11:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "Assignment",
+                                        "operator": "=",
+                                        "rightHandSide": {
+                                            "id": 5683,
+                                            "name": "_depth",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5674,
+                                            "src": "18362:6:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "18348:20:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "id": 5685,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18348:20:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5686,
+                                        "name": "self",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5672,
+                                        "src": "18385:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage storage pointer"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5679,
+                                    "id": 5687,
+                                    "nodeType": "Return",
+                                    "src": "18378:11:6"
+                                }
+                            ]
+                        },
+                        "id": 5689,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "depth",
+                        "nameLocation": "18253:5:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5675,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5672,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18278:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5689,
+                                    "src": "18259:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5671,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5670,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18259:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18259:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5674,
+                                    "mutability": "mutable",
+                                    "name": "_depth",
+                                    "nameLocation": "18292:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5689,
+                                    "src": "18284:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5673,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18284:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18258:41:6"
+                        },
+                        "returnParameters": {
+                            "id": 5679,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5678,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5689,
+                                    "src": "18318:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5677,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5676,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18318:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18318:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18317:20:6"
+                        },
+                        "scope": 5990,
+                        "src": "18244:152:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5711,
+                            "nodeType": "Block",
+                            "src": "18472:68:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5698,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5692,
+                                                "src": "18496:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "arguments": [
+                                                                    {
+                                                                        "id": 5705,
+                                                                        "name": "who",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5694,
+                                                                        "src": "18526:3:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "argumentTypes": [
+                                                                        {
+                                                                            "typeIdentifier": "t_address",
+                                                                            "typeString": "address"
+                                                                        }
+                                                                    ],
+                                                                    "id": 5704,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": true,
+                                                                    "lValueRequested": false,
+                                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                                    "src": "18518:7:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_type$_t_uint160_$",
+                                                                        "typeString": "type(uint160)"
+                                                                    },
+                                                                    "typeName": {
+                                                                        "id": 5703,
+                                                                        "name": "uint160",
+                                                                        "nodeType": "ElementaryTypeName",
+                                                                        "src": "18518:7:6",
+                                                                        "typeDescriptions": {}
+                                                                    }
+                                                                },
+                                                                "id": 5706,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": false,
+                                                                "kind": "typeConversion",
+                                                                "lValueRequested": false,
+                                                                "names": [],
+                                                                "nodeType": "FunctionCall",
+                                                                "src": "18518:12:6",
+                                                                "tryCall": false,
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_uint160",
+                                                                    "typeString": "uint160"
+                                                                }
+                                                            ],
+                                                            "id": 5702,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "ElementaryTypeNameExpression",
+                                                            "src": "18510:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_type$_t_uint256_$",
+                                                                "typeString": "type(uint256)"
+                                                            },
+                                                            "typeName": {
+                                                                "id": 5701,
+                                                                "name": "uint256",
+                                                                "nodeType": "ElementaryTypeName",
+                                                                "src": "18510:7:6",
+                                                                "typeDescriptions": {}
+                                                            }
+                                                        },
+                                                        "id": 5707,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "typeConversion",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "18510:21:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5700,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "18502:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5699,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "18502:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5708,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "18502:30:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5697,
+                                            "name": "checked_write",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                5712, 5729, 5747, 5892
+                                            ],
+                                            "referencedDeclaration": 5892,
+                                            "src": "18482:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (struct StdStorage storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5709,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18482:51:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5710,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18482:51:6"
+                                }
+                            ]
+                        },
+                        "id": 5712,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18411:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5695,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5692,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18444:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5712,
+                                    "src": "18425:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5691,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5690,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18425:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18425:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5694,
+                                    "mutability": "mutable",
+                                    "name": "who",
+                                    "nameLocation": "18458:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5712,
+                                    "src": "18450:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 5693,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18450:7:6",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18424:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5696,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18472:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18402:138:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5728,
+                            "nodeType": "Block",
+                            "src": "18616:50:6",
+                            "statements": [
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5721,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5715,
+                                                "src": "18640:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5724,
+                                                        "name": "amt",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5717,
+                                                        "src": "18654:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    ],
+                                                    "id": 5723,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "ElementaryTypeNameExpression",
+                                                    "src": "18646:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_type$_t_bytes32_$",
+                                                        "typeString": "type(bytes32)"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5722,
+                                                        "name": "bytes32",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "18646:7:6",
+                                                        "typeDescriptions": {}
+                                                    }
+                                                },
+                                                "id": 5725,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "typeConversion",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "18646:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5720,
+                                            "name": "checked_write",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                5712, 5729, 5747, 5892
+                                            ],
+                                            "referencedDeclaration": 5892,
+                                            "src": "18626:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (struct StdStorage storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5726,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18626:33:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5727,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18626:33:6"
+                                }
+                            ]
+                        },
+                        "id": 5729,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18555:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5718,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5715,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18588:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5729,
+                                    "src": "18569:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5714,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5713,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18569:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18569:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5717,
+                                    "mutability": "mutable",
+                                    "name": "amt",
+                                    "nameLocation": "18602:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5729,
+                                    "src": "18594:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5716,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18594:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18568:38:6"
+                        },
+                        "returnParameters": {
+                            "id": 5719,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18616:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18546:120:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5746,
+                            "nodeType": "Block",
+                            "src": "18741:153:6",
+                            "statements": [
+                                {
+                                    "assignments": [5738],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5738,
+                                            "mutability": "mutable",
+                                            "name": "t",
+                                            "nameLocation": "18759:1:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5746,
+                                            "src": "18751:9:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5737,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "18751:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5739,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "18751:9:6"
+                                },
+                                {
+                                    "AST": {
+                                        "nodeType": "YulBlock",
+                                        "src": "18822:34:6",
+                                        "statements": [
+                                            {
+                                                "nodeType": "YulAssignment",
+                                                "src": "18836:10:6",
+                                                "value": {
+                                                    "name": "write",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "18841:5:6"
+                                                },
+                                                "variableNames": [
+                                                    {
+                                                        "name": "t",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "18836:1:6"
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    },
+                                    "documentation": "@solidity memory-safe-assembly",
+                                    "evmVersion": "london",
+                                    "externalReferences": [
+                                        {
+                                            "declaration": 5738,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "18836:1:6",
+                                            "valueSize": 1
+                                        },
+                                        {
+                                            "declaration": 5734,
+                                            "isOffset": false,
+                                            "isSlot": false,
+                                            "src": "18841:5:6",
+                                            "valueSize": 1
+                                        }
+                                    ],
+                                    "id": 5740,
+                                    "nodeType": "InlineAssembly",
+                                    "src": "18813:43:6"
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5742,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5732,
+                                                "src": "18879:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            {
+                                                "id": 5743,
+                                                "name": "t",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5738,
+                                                "src": "18885:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "id": 5741,
+                                            "name": "checked_write",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [
+                                                5712, 5729, 5747, 5892
+                                            ],
+                                            "referencedDeclaration": 5892,
+                                            "src": "18865:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (struct StdStorage storage pointer,bytes32)"
+                                            }
+                                        },
+                                        "id": 5744,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "18865:22:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5745,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "18865:22:6"
+                                }
+                            ]
+                        },
+                        "id": 5747,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18681:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5735,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5732,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18714:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5747,
+                                    "src": "18695:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5731,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5730,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18695:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18695:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5734,
+                                    "mutability": "mutable",
+                                    "name": "write",
+                                    "nameLocation": "18725:5:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5747,
+                                    "src": "18720:10:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 5733,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18720:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18694:37:6"
+                        },
+                        "returnParameters": {
+                            "id": 5736,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18741:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18672:222:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5891,
+                            "nodeType": "Block",
+                            "src": "18992:966:6",
+                            "statements": [
+                                {
+                                    "assignments": [5756],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5756,
+                                            "mutability": "mutable",
+                                            "name": "who",
+                                            "nameLocation": "19010:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19002:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            },
+                                            "typeName": {
+                                                "id": 5755,
+                                                "name": "address",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19002:7:6",
+                                                "stateMutability": "nonpayable",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5759,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5757,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19016:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5758,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_target",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5030,
+                                        "src": "19016:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19002:26:6"
+                                },
+                                {
+                                    "assignments": [5761],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5761,
+                                            "mutability": "mutable",
+                                            "name": "fsig",
+                                            "nameLocation": "19045:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19038:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            },
+                                            "typeName": {
+                                                "id": 5760,
+                                                "name": "bytes4",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19038:6:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5764,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5762,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19052:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5763,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_sig",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5026,
+                                        "src": "19052:9:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19038:23:6"
+                                },
+                                {
+                                    "assignments": [5766],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5766,
+                                            "mutability": "mutable",
+                                            "name": "field_depth",
+                                            "nameLocation": "19079:11:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19071:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 5765,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19071:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5769,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5767,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19093:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5768,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_depth",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5028,
+                                        "src": "19093:11:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19071:33:6"
+                                },
+                                {
+                                    "assignments": [5774],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5774,
+                                            "mutability": "mutable",
+                                            "name": "ins",
+                                            "nameLocation": "19131:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19114:20:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                "typeString": "bytes32[]"
+                                            },
+                                            "typeName": {
+                                                "baseType": {
+                                                    "id": 5772,
+                                                    "name": "bytes32",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "19114:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5773,
+                                                "nodeType": "ArrayTypeName",
+                                                "src": "19114:9:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                                    "typeString": "bytes32[]"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5777,
+                                    "initialValue": {
+                                        "expression": {
+                                            "id": 5775,
+                                            "name": "self",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5750,
+                                            "src": "19137:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                "typeString": "struct StdStorage storage pointer"
+                                            }
+                                        },
+                                        "id": 5776,
+                                        "isConstant": false,
+                                        "isLValue": true,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "memberName": "_keys",
+                                        "nodeType": "MemberAccess",
+                                        "referencedDeclaration": 5024,
+                                        "src": "19137:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                            "typeString": "bytes32[] storage ref"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19114:33:6"
+                                },
+                                {
+                                    "assignments": [5779],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5779,
+                                            "mutability": "mutable",
+                                            "name": "cald",
+                                            "nameLocation": "19171:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19158:17:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 5778,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19158:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5787,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 5782,
+                                                "name": "fsig",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5761,
+                                                "src": "19195:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                }
+                                            },
+                                            {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5784,
+                                                        "name": "ins",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5774,
+                                                        "src": "19209:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    ],
+                                                    "id": 5783,
+                                                    "name": "flatten",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5989,
+                                                    "src": "19201:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_internal_pure$_t_array$_t_bytes32_$dyn_memory_ptr_$returns$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes32[] memory) pure returns (bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5785,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "19201:12:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_bytes4",
+                                                    "typeString": "bytes4"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5780,
+                                                "name": "abi",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": -1,
+                                                "src": "19178:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_magic_abi",
+                                                    "typeString": "abi"
+                                                }
+                                            },
+                                            "id": 5781,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "memberName": "encodePacked",
+                                            "nodeType": "MemberAccess",
+                                            "src": "19178:16:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function () pure returns (bytes memory)"
+                                            }
+                                        },
+                                        "id": 5786,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19178:36:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19158:56:6"
+                                },
+                                {
+                                    "condition": {
+                                        "id": 5802,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "!",
+                                        "prefix": true,
+                                        "src": "19228:69:6",
+                                        "subExpression": {
+                                            "baseExpression": {
+                                                "baseExpression": {
+                                                    "baseExpression": {
+                                                        "expression": {
+                                                            "id": 5788,
+                                                            "name": "self",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5750,
+                                                            "src": "19229:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        },
+                                                        "id": 5789,
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "memberName": "finds",
+                                                        "nodeType": "MemberAccess",
+                                                        "referencedDeclaration": 5021,
+                                                        "src": "19229:10:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$_$",
+                                                            "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => bool)))"
+                                                        }
+                                                    },
+                                                    "id": 5791,
+                                                    "indexExpression": {
+                                                        "id": 5790,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5756,
+                                                        "src": "19240:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "19229:15:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_bool_$_$",
+                                                        "typeString": "mapping(bytes4 => mapping(bytes32 => bool))"
+                                                    }
+                                                },
+                                                "id": 5793,
+                                                "indexExpression": {
+                                                    "id": 5792,
+                                                    "name": "fsig",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5761,
+                                                    "src": "19245:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes4",
+                                                        "typeString": "bytes4"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "19229:21:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_mapping$_t_bytes32_$_t_bool_$",
+                                                    "typeString": "mapping(bytes32 => bool)"
+                                                }
+                                            },
+                                            "id": 5801,
+                                            "indexExpression": {
+                                                "arguments": [
+                                                    {
+                                                        "arguments": [
+                                                            {
+                                                                "id": 5797,
+                                                                "name": "ins",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5774,
+                                                                "src": "19278:3:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                }
+                                                            },
+                                                            {
+                                                                "id": 5798,
+                                                                "name": "field_depth",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5766,
+                                                                "src": "19283:11:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            }
+                                                        ],
+                                                        "expression": {
+                                                            "argumentTypes": [
+                                                                {
+                                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                    "typeString": "bytes32[] memory"
+                                                                },
+                                                                {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "id": 5795,
+                                                                "name": "abi",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": -1,
+                                                                "src": "19261:3:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_magic_abi",
+                                                                    "typeString": "abi"
+                                                                }
+                                                            },
+                                                            "id": 5796,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "lValueRequested": false,
+                                                            "memberName": "encodePacked",
+                                                            "nodeType": "MemberAccess",
+                                                            "src": "19261:16:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                "typeString": "function () pure returns (bytes memory)"
+                                                            }
+                                                        },
+                                                        "id": 5799,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "kind": "functionCall",
+                                                        "lValueRequested": false,
+                                                        "names": [],
+                                                        "nodeType": "FunctionCall",
+                                                        "src": "19261:34:6",
+                                                        "tryCall": false,
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "id": 5794,
+                                                    "name": "keccak256",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": -8,
+                                                    "src": "19251:9:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                        "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                    }
+                                                },
+                                                "id": 5800,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "19251:45:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "IndexAccess",
+                                            "src": "19229:68:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5808,
+                                    "nodeType": "IfStatement",
+                                    "src": "19224:110:6",
+                                    "trueBody": {
+                                        "id": 5807,
+                                        "nodeType": "Block",
+                                        "src": "19299:35:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5804,
+                                                            "name": "self",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5750,
+                                                            "src": "19318:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                "typeString": "struct StdStorage storage pointer"
+                                                            }
+                                                        ],
+                                                        "id": 5803,
+                                                        "name": "find",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5529,
+                                                        "src": "19313:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_StdStorage_$5033_storage_ptr_$returns$_t_uint256_$",
+                                                            "typeString": "function (struct StdStorage storage pointer) returns (uint256)"
+                                                        }
+                                                    },
+                                                    "id": 5805,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19313:10:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "id": 5806,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "19313:10:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "assignments": [5810],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5810,
+                                            "mutability": "mutable",
+                                            "name": "slot",
+                                            "nameLocation": "19351:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19343:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5809,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19343:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5828,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "baseExpression": {
+                                                    "baseExpression": {
+                                                        "baseExpression": {
+                                                            "expression": {
+                                                                "id": 5813,
+                                                                "name": "self",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5750,
+                                                                "src": "19366:4:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                                    "typeString": "struct StdStorage storage pointer"
+                                                                }
+                                                            },
+                                                            "id": 5814,
+                                                            "isConstant": false,
+                                                            "isLValue": true,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "memberName": "slots",
+                                                            "nodeType": "MemberAccess",
+                                                            "referencedDeclaration": 5013,
+                                                            "src": "19366:10:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$_$",
+                                                                "typeString": "mapping(address => mapping(bytes4 => mapping(bytes32 => uint256)))"
+                                                            }
+                                                        },
+                                                        "id": 5816,
+                                                        "indexExpression": {
+                                                            "id": 5815,
+                                                            "name": "who",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5756,
+                                                            "src": "19377:3:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_address",
+                                                                "typeString": "address"
+                                                            }
+                                                        },
+                                                        "isConstant": false,
+                                                        "isLValue": true,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "nodeType": "IndexAccess",
+                                                        "src": "19366:15:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_mapping$_t_bytes4_$_t_mapping$_t_bytes32_$_t_uint256_$_$",
+                                                            "typeString": "mapping(bytes4 => mapping(bytes32 => uint256))"
+                                                        }
+                                                    },
+                                                    "id": 5818,
+                                                    "indexExpression": {
+                                                        "id": 5817,
+                                                        "name": "fsig",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5761,
+                                                        "src": "19382:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes4",
+                                                            "typeString": "bytes4"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "19366:21:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_mapping$_t_bytes32_$_t_uint256_$",
+                                                        "typeString": "mapping(bytes32 => uint256)"
+                                                    }
+                                                },
+                                                "id": 5826,
+                                                "indexExpression": {
+                                                    "arguments": [
+                                                        {
+                                                            "arguments": [
+                                                                {
+                                                                    "id": 5822,
+                                                                    "name": "ins",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5774,
+                                                                    "src": "19415:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    }
+                                                                },
+                                                                {
+                                                                    "id": 5823,
+                                                                    "name": "field_depth",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": 5766,
+                                                                    "src": "19420:11:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                                        "typeString": "bytes32[] memory"
+                                                                    },
+                                                                    {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                ],
+                                                                "expression": {
+                                                                    "id": 5820,
+                                                                    "name": "abi",
+                                                                    "nodeType": "Identifier",
+                                                                    "overloadedDeclarations": [],
+                                                                    "referencedDeclaration": -1,
+                                                                    "src": "19398:3:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_magic_abi",
+                                                                        "typeString": "abi"
+                                                                    }
+                                                                },
+                                                                "id": 5821,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "memberName": "encodePacked",
+                                                                "nodeType": "MemberAccess",
+                                                                "src": "19398:16:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$",
+                                                                    "typeString": "function () pure returns (bytes memory)"
+                                                                }
+                                                            },
+                                                            "id": 5824,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "functionCall",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "19398:34:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        ],
+                                                        "id": 5819,
+                                                        "name": "keccak256",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": -8,
+                                                        "src": "19388:9:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5825,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19388:45:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "isConstant": false,
+                                                "isLValue": true,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "nodeType": "IndexAccess",
+                                                "src": "19366:68:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "id": 5812,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "nodeType": "ElementaryTypeNameExpression",
+                                            "src": "19358:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_type$_t_bytes32_$",
+                                                "typeString": "type(bytes32)"
+                                            },
+                                            "typeName": {
+                                                "id": 5811,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19358:7:6",
+                                                "typeDescriptions": {}
+                                            }
+                                        },
+                                        "id": 5827,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "typeConversion",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19358:77:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19343:92:6"
+                                },
+                                {
+                                    "assignments": [5830],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5830,
+                                            "mutability": "mutable",
+                                            "name": "fdat",
+                                            "nameLocation": "19454:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19446:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5829,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19446:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5831,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19446:12:6"
+                                },
+                                {
+                                    "id": 5848,
+                                    "nodeType": "Block",
+                                    "src": "19468:126:6",
+                                    "statements": [
+                                        {
+                                            "assignments": [null, 5833],
+                                            "declarations": [
+                                                null,
+                                                {
+                                                    "constant": false,
+                                                    "id": 5833,
+                                                    "mutability": "mutable",
+                                                    "name": "rdat",
+                                                    "nameLocation": "19498:4:6",
+                                                    "nodeType": "VariableDeclaration",
+                                                    "scope": 5848,
+                                                    "src": "19485:17:6",
+                                                    "stateVariable": false,
+                                                    "storageLocation": "memory",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes"
+                                                    },
+                                                    "typeName": {
+                                                        "id": 5832,
+                                                        "name": "bytes",
+                                                        "nodeType": "ElementaryTypeName",
+                                                        "src": "19485:5:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                                            "typeString": "bytes"
+                                                        }
+                                                    },
+                                                    "visibility": "internal"
+                                                }
+                                            ],
+                                            "id": 5838,
+                                            "initialValue": {
+                                                "arguments": [
+                                                    {
+                                                        "id": 5836,
+                                                        "name": "cald",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5779,
+                                                        "src": "19521:4:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    }
+                                                ],
+                                                "expression": {
+                                                    "argumentTypes": [
+                                                        {
+                                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                                            "typeString": "bytes memory"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "id": 5834,
+                                                        "name": "who",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5756,
+                                                        "src": "19506:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_address",
+                                                            "typeString": "address"
+                                                        }
+                                                    },
+                                                    "id": 5835,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "staticcall",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "19506:14:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$",
+                                                        "typeString": "function (bytes memory) view returns (bool,bytes memory)"
+                                                    }
+                                                },
+                                                "id": 5837,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "kind": "functionCall",
+                                                "lValueRequested": false,
+                                                "names": [],
+                                                "nodeType": "FunctionCall",
+                                                "src": "19506:20:6",
+                                                "tryCall": false,
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$",
+                                                    "typeString": "tuple(bool,bytes memory)"
+                                                }
+                                            },
+                                            "nodeType": "VariableDeclarationStatement",
+                                            "src": "19482:44:6"
+                                        },
+                                        {
+                                            "expression": {
+                                                "id": 5846,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftHandSide": {
+                                                    "id": 5839,
+                                                    "name": "fdat",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5830,
+                                                    "src": "19540:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "Assignment",
+                                                "operator": "=",
+                                                "rightHandSide": {
+                                                    "arguments": [
+                                                        {
+                                                            "id": 5841,
+                                                            "name": "rdat",
+                                                            "nodeType": "Identifier",
+                                                            "overloadedDeclarations": [],
+                                                            "referencedDeclaration": 5833,
+                                                            "src": "19562:4:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            }
+                                                        },
+                                                        {
+                                                            "commonType": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            },
+                                                            "id": 5844,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "leftExpression": {
+                                                                "hexValue": "3332",
+                                                                "id": 5842,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "kind": "number",
+                                                                "lValueRequested": false,
+                                                                "nodeType": "Literal",
+                                                                "src": "19568:2:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_rational_32_by_1",
+                                                                    "typeString": "int_const 32"
+                                                                },
+                                                                "value": "32"
+                                                            },
+                                                            "nodeType": "BinaryOperation",
+                                                            "operator": "*",
+                                                            "rightExpression": {
+                                                                "id": 5843,
+                                                                "name": "field_depth",
+                                                                "nodeType": "Identifier",
+                                                                "overloadedDeclarations": [],
+                                                                "referencedDeclaration": 5766,
+                                                                "src": "19571:11:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_uint256",
+                                                                    "typeString": "uint256"
+                                                                }
+                                                            },
+                                                            "src": "19568:14:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                "typeString": "bytes memory"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        ],
+                                                        "id": 5840,
+                                                        "name": "bytesToBytes32",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5948,
+                                                        "src": "19547:14:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_internal_pure$_t_bytes_memory_ptr_$_t_uint256_$returns$_t_bytes32_$",
+                                                            "typeString": "function (bytes memory,uint256) pure returns (bytes32)"
+                                                        }
+                                                    },
+                                                    "id": 5845,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19547:36:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "src": "19540:43:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "id": 5847,
+                                            "nodeType": "ExpressionStatement",
+                                            "src": "19540:43:6"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "assignments": [5850],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5850,
+                                            "mutability": "mutable",
+                                            "name": "curr",
+                                            "nameLocation": "19611:4:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5891,
+                                            "src": "19603:12:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5849,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "19603:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5856,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "id": 5853,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5756,
+                                                "src": "19636:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 5854,
+                                                "name": "slot",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5810,
+                                                "src": "19641:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5851,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "19618:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5852,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "load",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6022,
+                                            "src": "19618:17:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$returns$_t_bytes32_$",
+                                                "typeString": "function (address,bytes32) external returns (bytes32)"
+                                            }
+                                        },
+                                        "id": 5855,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19618:28:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "19603:43:6"
+                                },
+                                {
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        },
+                                        "id": 5859,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 5857,
+                                            "name": "fdat",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5830,
+                                            "src": "19661:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "!=",
+                                        "rightExpression": {
+                                            "id": 5858,
+                                            "name": "curr",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5850,
+                                            "src": "19669:4:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "src": "19661:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5866,
+                                    "nodeType": "IfStatement",
+                                    "src": "19657:141:6",
+                                    "trueBody": {
+                                        "id": 5865,
+                                        "nodeType": "Block",
+                                        "src": "19675:123:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "arguments": [
+                                                        {
+                                                            "hexValue": "66616c7365",
+                                                            "id": 5861,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "bool",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "19697:5:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bool",
+                                                                "typeString": "bool"
+                                                            },
+                                                            "value": "false"
+                                                        },
+                                                        {
+                                                            "hexValue": "5061636b656420736c6f742e205468697320776f756c642063617573652064616e6765726f7573206f76657277726974696e6720616e642063757272656e746c792069736e7420737570706f72746564",
+                                                            "id": 5862,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": true,
+                                                            "kind": "string",
+                                                            "lValueRequested": false,
+                                                            "nodeType": "Literal",
+                                                            "src": "19704:82:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                            },
+                                                            "value": "Packed slot. This would cause dangerous overwriting and currently isnt supported"
+                                                        }
+                                                    ],
+                                                    "expression": {
+                                                        "argumentTypes": [
+                                                            {
+                                                                "typeIdentifier": "t_bool",
+                                                                "typeString": "bool"
+                                                            },
+                                                            {
+                                                                "typeIdentifier": "t_stringliteral_2a24a930ae29d7bc76bb67f5f541df8fdc64b9658cc5344e97a39e19ff2012a0",
+                                                                "typeString": "literal_string \"Packed slot. This would cause dangerous overwriting and currently isnt supported\""
+                                                            }
+                                                        ],
+                                                        "id": 5860,
+                                                        "name": "require",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [
+                                                            -18, -18
+                                                        ],
+                                                        "referencedDeclaration": -18,
+                                                        "src": "19689:7:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
+                                                            "typeString": "function (bool,string memory) pure"
+                                                        }
+                                                    },
+                                                    "id": 5863,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "kind": "functionCall",
+                                                    "lValueRequested": false,
+                                                    "names": [],
+                                                    "nodeType": "FunctionCall",
+                                                    "src": "19689:98:6",
+                                                    "tryCall": false,
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_tuple$__$",
+                                                        "typeString": "tuple()"
+                                                    }
+                                                },
+                                                "id": 5864,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "19689:98:6"
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "expression": {
+                                        "arguments": [
+                                            {
+                                                "id": 5870,
+                                                "name": "who",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5756,
+                                                "src": "19826:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                }
+                                            },
+                                            {
+                                                "id": 5871,
+                                                "name": "slot",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5810,
+                                                "src": "19831:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            {
+                                                "id": 5872,
+                                                "name": "set",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5752,
+                                                "src": "19837:3:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_address",
+                                                    "typeString": "address"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                },
+                                                {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            ],
+                                            "expression": {
+                                                "id": 5867,
+                                                "name": "vm_std_store",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5066,
+                                                "src": "19807:12:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_contract$_Vm_$6200",
+                                                    "typeString": "contract Vm"
+                                                }
+                                            },
+                                            "id": 5869,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "store",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 6031,
+                                            "src": "19807:18:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_bytes32_$_t_bytes32_$returns$__$",
+                                                "typeString": "function (address,bytes32,bytes32) external"
+                                            }
+                                        },
+                                        "id": 5873,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "19807:34:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5874,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19807:34:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5877,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19851:19:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5875,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19858:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5876,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_target",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5030,
+                                            "src": "19858:12:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_address",
+                                                "typeString": "address"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5878,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19851:19:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5881,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19880:16:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5879,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19887:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5880,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_sig",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5026,
+                                            "src": "19887:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes4",
+                                                "typeString": "bytes4"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5882,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19880:16:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5885,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19906:17:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5883,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19913:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5884,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_keys",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5024,
+                                            "src": "19913:10:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_array$_t_bytes32_$dyn_storage",
+                                                "typeString": "bytes32[] storage ref"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5886,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19906:17:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5889,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "UnaryOperation",
+                                        "operator": "delete",
+                                        "prefix": true,
+                                        "src": "19933:18:6",
+                                        "subExpression": {
+                                            "expression": {
+                                                "id": 5887,
+                                                "name": "self",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5750,
+                                                "src": "19940:4:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                                    "typeString": "struct StdStorage storage pointer"
+                                                }
+                                            },
+                                            "id": 5888,
+                                            "isConstant": false,
+                                            "isLValue": true,
+                                            "isPure": false,
+                                            "lValueRequested": true,
+                                            "memberName": "_depth",
+                                            "nodeType": "MemberAccess",
+                                            "referencedDeclaration": 5028,
+                                            "src": "19940:11:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_tuple$__$",
+                                            "typeString": "tuple()"
+                                        }
+                                    },
+                                    "id": 5890,
+                                    "nodeType": "ExpressionStatement",
+                                    "src": "19933:18:6"
+                                }
+                            ]
+                        },
+                        "id": 5892,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "checked_write",
+                        "nameLocation": "18909:13:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5753,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5750,
+                                    "mutability": "mutable",
+                                    "name": "self",
+                                    "nameLocation": "18951:4:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5892,
+                                    "src": "18932:23:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "storage",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                        "typeString": "struct StdStorage"
+                                    },
+                                    "typeName": {
+                                        "id": 5749,
+                                        "nodeType": "UserDefinedTypeName",
+                                        "pathNode": {
+                                            "id": 5748,
+                                            "name": "StdStorage",
+                                            "nodeType": "IdentifierPath",
+                                            "referencedDeclaration": 5033,
+                                            "src": "18932:10:6"
+                                        },
+                                        "referencedDeclaration": 5033,
+                                        "src": "18932:10:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_struct$_StdStorage_$5033_storage_ptr",
+                                            "typeString": "struct StdStorage"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5752,
+                                    "mutability": "mutable",
+                                    "name": "set",
+                                    "nameLocation": "18973:3:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5892,
+                                    "src": "18965:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5751,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "18965:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "18922:60:6"
+                        },
+                        "returnParameters": {
+                            "id": 5754,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "18992:0:6"
+                        },
+                        "scope": 5990,
+                        "src": "18900:1058:6",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "internal"
+                    },
+                    {
+                        "body": {
+                            "id": 5947,
+                            "nodeType": "Block",
+                            "src": "20047:214:6",
+                            "statements": [
+                                {
+                                    "assignments": [5902],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5902,
+                                            "mutability": "mutable",
+                                            "name": "out",
+                                            "nameLocation": "20065:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5947,
+                                            "src": "20057:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            },
+                                            "typeName": {
+                                                "id": 5901,
+                                                "name": "bytes32",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20057:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes32",
+                                                    "typeString": "bytes32"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5903,
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "20057:11:6"
+                                },
+                                {
+                                    "assignments": [5905],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5905,
+                                            "mutability": "mutable",
+                                            "name": "max",
+                                            "nameLocation": "20087:3:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5947,
+                                            "src": "20079:11:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "default",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "typeName": {
+                                                "id": 5904,
+                                                "name": "uint256",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20079:7:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5914,
+                                    "initialValue": {
+                                        "condition": {
+                                            "commonType": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            },
+                                            "id": 5909,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "leftExpression": {
+                                                "expression": {
+                                                    "id": 5906,
+                                                    "name": "b",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 5894,
+                                                    "src": "20093:1:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                                        "typeString": "bytes memory"
+                                                    }
+                                                },
+                                                "id": 5907,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "memberName": "length",
+                                                "nodeType": "MemberAccess",
+                                                "src": "20093:8:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "nodeType": "BinaryOperation",
+                                            "operator": ">",
+                                            "rightExpression": {
+                                                "hexValue": "3332",
+                                                "id": 5908,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "number",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "20104:2:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_rational_32_by_1",
+                                                    "typeString": "int_const 32"
+                                                },
+                                                "value": "32"
+                                            },
+                                            "src": "20093:13:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bool",
+                                                "typeString": "bool"
+                                            }
+                                        },
+                                        "falseExpression": {
+                                            "expression": {
+                                                "id": 5911,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5894,
+                                                "src": "20114:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_memory_ptr",
+                                                    "typeString": "bytes memory"
+                                                }
+                                            },
+                                            "id": 5912,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "length",
+                                            "nodeType": "MemberAccess",
+                                            "src": "20114:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 5913,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "nodeType": "Conditional",
+                                        "src": "20093:29:6",
+                                        "trueExpression": {
+                                            "hexValue": "3332",
+                                            "id": 5910,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "20109:2:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_32_by_1",
+                                                "typeString": "int_const 32"
+                                            },
+                                            "value": "32"
+                                        },
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "20079:43:6"
+                                },
+                                {
+                                    "body": {
+                                        "id": 5943,
+                                        "nodeType": "Block",
+                                        "src": "20163:72:6",
+                                        "statements": [
+                                            {
+                                                "expression": {
+                                                    "id": 5941,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "leftHandSide": {
+                                                        "id": 5925,
+                                                        "name": "out",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5902,
+                                                        "src": "20177:3:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "nodeType": "Assignment",
+                                                    "operator": "|=",
+                                                    "rightHandSide": {
+                                                        "commonType": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        },
+                                                        "id": 5940,
+                                                        "isConstant": false,
+                                                        "isLValue": false,
+                                                        "isPure": false,
+                                                        "lValueRequested": false,
+                                                        "leftExpression": {
+                                                            "arguments": [
+                                                                {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_bytes1",
+                                                                        "typeString": "bytes1"
+                                                                    },
+                                                                    "id": 5934,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "baseExpression": {
+                                                                            "id": 5928,
+                                                                            "name": "b",
+                                                                            "nodeType": "Identifier",
+                                                                            "overloadedDeclarations": [],
+                                                                            "referencedDeclaration": 5894,
+                                                                            "src": "20192:1:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                                                "typeString": "bytes memory"
+                                                                            }
+                                                                        },
+                                                                        "id": 5932,
+                                                                        "indexExpression": {
+                                                                            "commonType": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            },
+                                                                            "id": 5931,
+                                                                            "isConstant": false,
+                                                                            "isLValue": false,
+                                                                            "isPure": false,
+                                                                            "lValueRequested": false,
+                                                                            "leftExpression": {
+                                                                                "id": 5929,
+                                                                                "name": "offset",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5896,
+                                                                                "src": "20194:6:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "nodeType": "BinaryOperation",
+                                                                            "operator": "+",
+                                                                            "rightExpression": {
+                                                                                "id": 5930,
+                                                                                "name": "i",
+                                                                                "nodeType": "Identifier",
+                                                                                "overloadedDeclarations": [],
+                                                                                "referencedDeclaration": 5916,
+                                                                                "src": "20203:1:6",
+                                                                                "typeDescriptions": {
+                                                                                    "typeIdentifier": "t_uint256",
+                                                                                    "typeString": "uint256"
+                                                                                }
+                                                                            },
+                                                                            "src": "20194:10:6",
+                                                                            "typeDescriptions": {
+                                                                                "typeIdentifier": "t_uint256",
+                                                                                "typeString": "uint256"
+                                                                            }
+                                                                        },
+                                                                        "isConstant": false,
+                                                                        "isLValue": true,
+                                                                        "isPure": false,
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "IndexAccess",
+                                                                        "src": "20192:13:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_bytes1",
+                                                                            "typeString": "bytes1"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "&",
+                                                                    "rightExpression": {
+                                                                        "hexValue": "30784646",
+                                                                        "id": 5933,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "number",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "20208:4:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_rational_255_by_1",
+                                                                            "typeString": "int_const 255"
+                                                                        },
+                                                                        "value": "0xFF"
+                                                                    },
+                                                                    "src": "20192:20:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_bytes1",
+                                                                        "typeString": "bytes1"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "expression": {
+                                                                "argumentTypes": [
+                                                                    {
+                                                                        "typeIdentifier": "t_bytes1",
+                                                                        "typeString": "bytes1"
+                                                                    }
+                                                                ],
+                                                                "id": 5927,
+                                                                "isConstant": false,
+                                                                "isLValue": false,
+                                                                "isPure": true,
+                                                                "lValueRequested": false,
+                                                                "nodeType": "ElementaryTypeNameExpression",
+                                                                "src": "20184:7:6",
+                                                                "typeDescriptions": {
+                                                                    "typeIdentifier": "t_type$_t_bytes32_$",
+                                                                    "typeString": "type(bytes32)"
+                                                                },
+                                                                "typeName": {
+                                                                    "id": 5926,
+                                                                    "name": "bytes32",
+                                                                    "nodeType": "ElementaryTypeName",
+                                                                    "src": "20184:7:6",
+                                                                    "typeDescriptions": {}
+                                                                }
+                                                            },
+                                                            "id": 5935,
+                                                            "isConstant": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "kind": "typeConversion",
+                                                            "lValueRequested": false,
+                                                            "names": [],
+                                                            "nodeType": "FunctionCall",
+                                                            "src": "20184:29:6",
+                                                            "tryCall": false,
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "nodeType": "BinaryOperation",
+                                                        "operator": ">>",
+                                                        "rightExpression": {
+                                                            "components": [
+                                                                {
+                                                                    "commonType": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    },
+                                                                    "id": 5938,
+                                                                    "isConstant": false,
+                                                                    "isLValue": false,
+                                                                    "isPure": false,
+                                                                    "lValueRequested": false,
+                                                                    "leftExpression": {
+                                                                        "id": 5936,
+                                                                        "name": "i",
+                                                                        "nodeType": "Identifier",
+                                                                        "overloadedDeclarations": [],
+                                                                        "referencedDeclaration": 5916,
+                                                                        "src": "20218:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_uint256",
+                                                                            "typeString": "uint256"
+                                                                        }
+                                                                    },
+                                                                    "nodeType": "BinaryOperation",
+                                                                    "operator": "*",
+                                                                    "rightExpression": {
+                                                                        "hexValue": "38",
+                                                                        "id": 5937,
+                                                                        "isConstant": false,
+                                                                        "isLValue": false,
+                                                                        "isPure": true,
+                                                                        "kind": "number",
+                                                                        "lValueRequested": false,
+                                                                        "nodeType": "Literal",
+                                                                        "src": "20222:1:6",
+                                                                        "typeDescriptions": {
+                                                                            "typeIdentifier": "t_rational_8_by_1",
+                                                                            "typeString": "int_const 8"
+                                                                        },
+                                                                        "value": "8"
+                                                                    },
+                                                                    "src": "20218:5:6",
+                                                                    "typeDescriptions": {
+                                                                        "typeIdentifier": "t_uint256",
+                                                                        "typeString": "uint256"
+                                                                    }
+                                                                }
+                                                            ],
+                                                            "id": 5939,
+                                                            "isConstant": false,
+                                                            "isInlineArray": false,
+                                                            "isLValue": false,
+                                                            "isPure": false,
+                                                            "lValueRequested": false,
+                                                            "nodeType": "TupleExpression",
+                                                            "src": "20217:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_uint256",
+                                                                "typeString": "uint256"
+                                                            }
+                                                        },
+                                                        "src": "20184:40:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        }
+                                                    },
+                                                    "src": "20177:47:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "id": 5942,
+                                                "nodeType": "ExpressionStatement",
+                                                "src": "20177:47:6"
+                                            }
+                                        ]
+                                    },
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 5921,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 5919,
+                                            "name": "i",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5916,
+                                            "src": "20149:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "<",
+                                        "rightExpression": {
+                                            "id": 5920,
+                                            "name": "max",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5905,
+                                            "src": "20153:3:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "20149:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5944,
+                                    "initializationExpression": {
+                                        "assignments": [5916],
+                                        "declarations": [
+                                            {
+                                                "constant": false,
+                                                "id": 5916,
+                                                "mutability": "mutable",
+                                                "name": "i",
+                                                "nameLocation": "20142:1:6",
+                                                "nodeType": "VariableDeclaration",
+                                                "scope": 5944,
+                                                "src": "20137:6:6",
+                                                "stateVariable": false,
+                                                "storageLocation": "default",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "typeName": {
+                                                    "id": 5915,
+                                                    "name": "uint",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "20137:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "visibility": "internal"
+                                            }
+                                        ],
+                                        "id": 5918,
+                                        "initialValue": {
+                                            "hexValue": "30",
+                                            "id": 5917,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "20146:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "nodeType": "VariableDeclarationStatement",
+                                        "src": "20137:10:6"
+                                    },
+                                    "loopExpression": {
+                                        "expression": {
+                                            "id": 5923,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "UnaryOperation",
+                                            "operator": "++",
+                                            "prefix": false,
+                                            "src": "20158:3:6",
+                                            "subExpression": {
+                                                "id": 5922,
+                                                "name": "i",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5916,
+                                                "src": "20158:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 5924,
+                                        "nodeType": "ExpressionStatement",
+                                        "src": "20158:3:6"
+                                    },
+                                    "nodeType": "ForStatement",
+                                    "src": "20132:103:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5945,
+                                        "name": "out",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5902,
+                                        "src": "20251:3:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5900,
+                                    "id": 5946,
+                                    "nodeType": "Return",
+                                    "src": "20244:10:6"
+                                }
+                            ]
+                        },
+                        "functionSelector": "53584939",
+                        "id": 5948,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "bytesToBytes32",
+                        "nameLocation": "19973:14:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5897,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5894,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "20001:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5948,
+                                    "src": "19988:14:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 5893,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "19988:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 5896,
+                                    "mutability": "mutable",
+                                    "name": "offset",
+                                    "nameLocation": "20009:6:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5948,
+                                    "src": "20004:11:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5895,
+                                        "name": "uint",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "20004:4:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "19987:29:6"
+                        },
+                        "returnParameters": {
+                            "id": 5900,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5899,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5948,
+                                    "src": "20038:7:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 5898,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "20038:7:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "20037:9:6"
+                        },
+                        "scope": 5990,
+                        "src": "19964:297:6",
+                        "stateMutability": "pure",
+                        "virtual": false,
+                        "visibility": "public"
+                    },
+                    {
+                        "body": {
+                            "id": 5988,
+                            "nodeType": "Block",
+                            "src": "20344:320:6",
+                            "statements": [
+                                {
+                                    "assignments": [5957],
+                                    "declarations": [
+                                        {
+                                            "constant": false,
+                                            "id": 5957,
+                                            "mutability": "mutable",
+                                            "name": "result",
+                                            "nameLocation": "20367:6:6",
+                                            "nodeType": "VariableDeclaration",
+                                            "scope": 5988,
+                                            "src": "20354:19:6",
+                                            "stateVariable": false,
+                                            "storageLocation": "memory",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes_memory_ptr",
+                                                "typeString": "bytes"
+                                            },
+                                            "typeName": {
+                                                "id": 5956,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20354:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            },
+                                            "visibility": "internal"
+                                        }
+                                    ],
+                                    "id": 5965,
+                                    "initialValue": {
+                                        "arguments": [
+                                            {
+                                                "commonType": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "id": 5963,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftExpression": {
+                                                    "expression": {
+                                                        "id": 5960,
+                                                        "name": "b",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5951,
+                                                        "src": "20386:1:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    },
+                                                    "id": 5961,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "memberName": "length",
+                                                    "nodeType": "MemberAccess",
+                                                    "src": "20386:8:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "BinaryOperation",
+                                                "operator": "*",
+                                                "rightExpression": {
+                                                    "hexValue": "3332",
+                                                    "id": 5962,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "20397:2:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_rational_32_by_1",
+                                                        "typeString": "int_const 32"
+                                                    },
+                                                    "value": "32"
+                                                },
+                                                "src": "20386:13:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            }
+                                        ],
+                                        "expression": {
+                                            "argumentTypes": [
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            ],
+                                            "id": 5959,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "lValueRequested": false,
+                                            "nodeType": "NewExpression",
+                                            "src": "20376:9:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_function_objectcreation_pure$_t_uint256_$returns$_t_bytes_memory_ptr_$",
+                                                "typeString": "function (uint256) pure returns (bytes memory)"
+                                            },
+                                            "typeName": {
+                                                "id": 5958,
+                                                "name": "bytes",
+                                                "nodeType": "ElementaryTypeName",
+                                                "src": "20380:5:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_bytes_storage_ptr",
+                                                    "typeString": "bytes"
+                                                }
+                                            }
+                                        },
+                                        "id": 5964,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "kind": "functionCall",
+                                        "lValueRequested": false,
+                                        "names": [],
+                                        "nodeType": "FunctionCall",
+                                        "src": "20376:24:6",
+                                        "tryCall": false,
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "nodeType": "VariableDeclarationStatement",
+                                    "src": "20354:46:6"
+                                },
+                                {
+                                    "body": {
+                                        "id": 5984,
+                                        "nodeType": "Block",
+                                        "src": "20449:185:6",
+                                        "statements": [
+                                            {
+                                                "assignments": [5978],
+                                                "declarations": [
+                                                    {
+                                                        "constant": false,
+                                                        "id": 5978,
+                                                        "mutability": "mutable",
+                                                        "name": "k",
+                                                        "nameLocation": "20471:1:6",
+                                                        "nodeType": "VariableDeclaration",
+                                                        "scope": 5984,
+                                                        "src": "20463:9:6",
+                                                        "stateVariable": false,
+                                                        "storageLocation": "default",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_bytes32",
+                                                            "typeString": "bytes32"
+                                                        },
+                                                        "typeName": {
+                                                            "id": 5977,
+                                                            "name": "bytes32",
+                                                            "nodeType": "ElementaryTypeName",
+                                                            "src": "20463:7:6",
+                                                            "typeDescriptions": {
+                                                                "typeIdentifier": "t_bytes32",
+                                                                "typeString": "bytes32"
+                                                            }
+                                                        },
+                                                        "visibility": "internal"
+                                                    }
+                                                ],
+                                                "id": 5982,
+                                                "initialValue": {
+                                                    "baseExpression": {
+                                                        "id": 5979,
+                                                        "name": "b",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5951,
+                                                        "src": "20475:1:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                            "typeString": "bytes32[] memory"
+                                                        }
+                                                    },
+                                                    "id": 5981,
+                                                    "indexExpression": {
+                                                        "id": 5980,
+                                                        "name": "i",
+                                                        "nodeType": "Identifier",
+                                                        "overloadedDeclarations": [],
+                                                        "referencedDeclaration": 5967,
+                                                        "src": "20477:1:6",
+                                                        "typeDescriptions": {
+                                                            "typeIdentifier": "t_uint256",
+                                                            "typeString": "uint256"
+                                                        }
+                                                    },
+                                                    "isConstant": false,
+                                                    "isLValue": true,
+                                                    "isPure": false,
+                                                    "lValueRequested": false,
+                                                    "nodeType": "IndexAccess",
+                                                    "src": "20475:4:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_bytes32",
+                                                        "typeString": "bytes32"
+                                                    }
+                                                },
+                                                "nodeType": "VariableDeclarationStatement",
+                                                "src": "20463:16:6"
+                                            },
+                                            {
+                                                "AST": {
+                                                    "nodeType": "YulBlock",
+                                                    "src": "20549:75:6",
+                                                    "statements": [
+                                                        {
+                                                            "expression": {
+                                                                "arguments": [
+                                                                    {
+                                                                        "arguments": [
+                                                                            {
+                                                                                "name": "result",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "20578:6:6"
+                                                                            },
+                                                                            {
+                                                                                "arguments": [
+                                                                                    {
+                                                                                        "kind": "number",
+                                                                                        "nodeType": "YulLiteral",
+                                                                                        "src": "20590:2:6",
+                                                                                        "type": "",
+                                                                                        "value": "32"
+                                                                                    },
+                                                                                    {
+                                                                                        "arguments": [
+                                                                                            {
+                                                                                                "kind": "number",
+                                                                                                "nodeType": "YulLiteral",
+                                                                                                "src": "20598:2:6",
+                                                                                                "type": "",
+                                                                                                "value": "32"
+                                                                                            },
+                                                                                            {
+                                                                                                "name": "i",
+                                                                                                "nodeType": "YulIdentifier",
+                                                                                                "src": "20602:1:6"
+                                                                                            }
+                                                                                        ],
+                                                                                        "functionName": {
+                                                                                            "name": "mul",
+                                                                                            "nodeType": "YulIdentifier",
+                                                                                            "src": "20594:3:6"
+                                                                                        },
+                                                                                        "nodeType": "YulFunctionCall",
+                                                                                        "src": "20594:10:6"
+                                                                                    }
+                                                                                ],
+                                                                                "functionName": {
+                                                                                    "name": "add",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "20586:3:6"
+                                                                                },
+                                                                                "nodeType": "YulFunctionCall",
+                                                                                "src": "20586:19:6"
+                                                                            }
+                                                                        ],
+                                                                        "functionName": {
+                                                                            "name": "add",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "20574:3:6"
+                                                                        },
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "20574:32:6"
+                                                                    },
+                                                                    {
+                                                                        "name": "k",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "20608:1:6"
+                                                                    }
+                                                                ],
+                                                                "functionName": {
+                                                                    "name": "mstore",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "20567:6:6"
+                                                                },
+                                                                "nodeType": "YulFunctionCall",
+                                                                "src": "20567:43:6"
+                                                            },
+                                                            "nodeType": "YulExpressionStatement",
+                                                            "src": "20567:43:6"
+                                                        }
+                                                    ]
+                                                },
+                                                "documentation": "@solidity memory-safe-assembly",
+                                                "evmVersion": "london",
+                                                "externalReferences": [
+                                                    {
+                                                        "declaration": 5967,
+                                                        "isOffset": false,
+                                                        "isSlot": false,
+                                                        "src": "20602:1:6",
+                                                        "valueSize": 1
+                                                    },
+                                                    {
+                                                        "declaration": 5978,
+                                                        "isOffset": false,
+                                                        "isSlot": false,
+                                                        "src": "20608:1:6",
+                                                        "valueSize": 1
+                                                    },
+                                                    {
+                                                        "declaration": 5957,
+                                                        "isOffset": false,
+                                                        "isSlot": false,
+                                                        "src": "20578:6:6",
+                                                        "valueSize": 1
+                                                    }
+                                                ],
+                                                "id": 5983,
+                                                "nodeType": "InlineAssembly",
+                                                "src": "20540:84:6"
+                                            }
+                                        ]
+                                    },
+                                    "condition": {
+                                        "commonType": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        },
+                                        "id": 5973,
+                                        "isConstant": false,
+                                        "isLValue": false,
+                                        "isPure": false,
+                                        "lValueRequested": false,
+                                        "leftExpression": {
+                                            "id": 5970,
+                                            "name": "i",
+                                            "nodeType": "Identifier",
+                                            "overloadedDeclarations": [],
+                                            "referencedDeclaration": 5967,
+                                            "src": "20430:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "nodeType": "BinaryOperation",
+                                        "operator": "<",
+                                        "rightExpression": {
+                                            "expression": {
+                                                "id": 5971,
+                                                "name": "b",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5951,
+                                                "src": "20434:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                                    "typeString": "bytes32[] memory"
+                                                }
+                                            },
+                                            "id": 5972,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "memberName": "length",
+                                            "nodeType": "MemberAccess",
+                                            "src": "20434:8:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "src": "20430:12:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "id": 5985,
+                                    "initializationExpression": {
+                                        "assignments": [5967],
+                                        "declarations": [
+                                            {
+                                                "constant": false,
+                                                "id": 5967,
+                                                "mutability": "mutable",
+                                                "name": "i",
+                                                "nameLocation": "20423:1:6",
+                                                "nodeType": "VariableDeclaration",
+                                                "scope": 5985,
+                                                "src": "20415:9:6",
+                                                "stateVariable": false,
+                                                "storageLocation": "default",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                },
+                                                "typeName": {
+                                                    "id": 5966,
+                                                    "name": "uint256",
+                                                    "nodeType": "ElementaryTypeName",
+                                                    "src": "20415:7:6",
+                                                    "typeDescriptions": {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "visibility": "internal"
+                                            }
+                                        ],
+                                        "id": 5969,
+                                        "initialValue": {
+                                            "hexValue": "30",
+                                            "id": 5968,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": true,
+                                            "kind": "number",
+                                            "lValueRequested": false,
+                                            "nodeType": "Literal",
+                                            "src": "20427:1:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_rational_0_by_1",
+                                                "typeString": "int_const 0"
+                                            },
+                                            "value": "0"
+                                        },
+                                        "nodeType": "VariableDeclarationStatement",
+                                        "src": "20415:13:6"
+                                    },
+                                    "loopExpression": {
+                                        "expression": {
+                                            "id": 5975,
+                                            "isConstant": false,
+                                            "isLValue": false,
+                                            "isPure": false,
+                                            "lValueRequested": false,
+                                            "nodeType": "UnaryOperation",
+                                            "operator": "++",
+                                            "prefix": false,
+                                            "src": "20444:3:6",
+                                            "subExpression": {
+                                                "id": 5974,
+                                                "name": "i",
+                                                "nodeType": "Identifier",
+                                                "overloadedDeclarations": [],
+                                                "referencedDeclaration": 5967,
+                                                "src": "20444:1:6",
+                                                "typeDescriptions": {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_uint256",
+                                                "typeString": "uint256"
+                                            }
+                                        },
+                                        "id": 5976,
+                                        "nodeType": "ExpressionStatement",
+                                        "src": "20444:3:6"
+                                    },
+                                    "nodeType": "ForStatement",
+                                    "src": "20410:224:6"
+                                },
+                                {
+                                    "expression": {
+                                        "id": 5986,
+                                        "name": "result",
+                                        "nodeType": "Identifier",
+                                        "overloadedDeclarations": [],
+                                        "referencedDeclaration": 5957,
+                                        "src": "20651:6:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_memory_ptr",
+                                            "typeString": "bytes memory"
+                                        }
+                                    },
+                                    "functionReturnParameters": 5955,
+                                    "id": 5987,
+                                    "nodeType": "Return",
+                                    "src": "20644:13:6"
+                                }
+                            ]
+                        },
+                        "id": 5989,
+                        "implemented": true,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "flatten",
+                        "nameLocation": "20276:7:6",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5952,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5951,
+                                    "mutability": "mutable",
+                                    "name": "b",
+                                    "nameLocation": "20301:1:6",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5989,
+                                    "src": "20284:18:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                        "typeString": "bytes32[]"
+                                    },
+                                    "typeName": {
+                                        "baseType": {
+                                            "id": 5949,
+                                            "name": "bytes32",
+                                            "nodeType": "ElementaryTypeName",
+                                            "src": "20284:7:6",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "id": 5950,
+                                        "nodeType": "ArrayTypeName",
+                                        "src": "20284:9:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                            "typeString": "bytes32[]"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "20283:20:6"
+                        },
+                        "returnParameters": {
+                            "id": 5955,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5954,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5989,
+                                    "src": "20326:12:6",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 5953,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "20326:5:6",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "20325:14:6"
+                        },
+                        "scope": 5990,
+                        "src": "20267:397:6",
+                        "stateMutability": "pure",
+                        "virtual": false,
+                        "visibility": "private"
+                    }
+                ],
+                "scope": 5991,
+                "src": "13204:7462:6",
+                "usedErrors": []
+            }
+        ],
+        "src": "38:20629:6"
+    }
+}
diff --git a/out/Vm.sol/Vm.json b/out/Vm.sol/Vm.json
new file mode 100644
index 0000000..3a72a96
--- /dev/null
+++ b/out/Vm.sol/Vm.json
@@ -0,0 +1,2984 @@
+{
+    "abi": [
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "accesses",
+            "outputs": [
+                {
+                    "internalType": "bytes32[]",
+                    "name": "reads",
+                    "type": "bytes32[]"
+                },
+                {
+                    "internalType": "bytes32[]",
+                    "name": "writes",
+                    "type": "bytes32[]"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "addr",
+            "outputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "name": "assume",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "chainId",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "clearMockedCalls",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "deal",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "name": "etch",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "name": "expectCall",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                },
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                },
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                },
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "name": "expectEmit",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "bytes4",
+                    "name": "",
+                    "type": "bytes4"
+                }
+            ],
+            "name": "expectRevert",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "name": "expectRevert",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "expectRevert",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "fee",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "string[]",
+                    "name": "",
+                    "type": "string[]"
+                }
+            ],
+            "name": "ffi",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "string",
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "name": "getCode",
+            "outputs": [
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "getNonce",
+            "outputs": [
+                {
+                    "internalType": "uint64",
+                    "name": "",
+                    "type": "uint64"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "string",
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "name": "label",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "bytes32",
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "load",
+            "outputs": [
+                {
+                    "internalType": "bytes32",
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                },
+                {
+                    "internalType": "bytes",
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "name": "mockCall",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "prank",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "prank",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "record",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "roll",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint64",
+                    "name": "",
+                    "type": "uint64"
+                }
+            ],
+            "name": "setNonce",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "bytes32",
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "sign",
+            "outputs": [
+                {
+                    "internalType": "uint8",
+                    "name": "",
+                    "type": "uint8"
+                },
+                {
+                    "internalType": "bytes32",
+                    "name": "",
+                    "type": "bytes32"
+                },
+                {
+                    "internalType": "bytes32",
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "startPrank",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "startPrank",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "stopPrank",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "bytes32",
+                    "name": "",
+                    "type": "bytes32"
+                },
+                {
+                    "internalType": "bytes32",
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "store",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "tip",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "warp",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        }
+    ],
+    "bytecode": {
+        "object": "0x",
+        "sourceMap": "",
+        "linkReferences": {}
+    },
+    "deployedBytecode": {
+        "object": "0x",
+        "sourceMap": "",
+        "linkReferences": {}
+    },
+    "ast": {
+        "absolutePath": "/Users/koda/Desktop/repos/latest/tracer-vaults/lib/forge-std/src/Vm.sol",
+        "exportedSymbols": {
+            "Vm": [6200]
+        },
+        "id": 6201,
+        "license": "Unlicense",
+        "nodeType": "SourceUnit",
+        "nodes": [
+            {
+                "id": 5992,
+                "literals": ["solidity", ">=", "0.6", ".0"],
+                "nodeType": "PragmaDirective",
+                "src": "38:24:7"
+            },
+            {
+                "id": 5993,
+                "literals": ["experimental", "ABIEncoderV2"],
+                "nodeType": "PragmaDirective",
+                "src": "63:33:7"
+            },
+            {
+                "abstract": false,
+                "baseContracts": [],
+                "canonicalName": "Vm",
+                "contractDependencies": [],
+                "contractKind": "interface",
+                "fullyImplemented": false,
+                "id": 6200,
+                "linearizedBaseContracts": [6200],
+                "name": "Vm",
+                "nameLocation": "108:2:7",
+                "nodeType": "ContractDefinition",
+                "nodes": [
+                    {
+                        "functionSelector": "e5d6bf02",
+                        "id": 5998,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "warp",
+                        "nameLocation": "168:4:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 5996,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 5995,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 5998,
+                                    "src": "173:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5994,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "173:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "172:9:7"
+                        },
+                        "returnParameters": {
+                            "id": 5997,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "190:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "159:32:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "1f7b4f30",
+                        "id": 6003,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "roll",
+                        "nameLocation": "241:4:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6001,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6000,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6003,
+                                    "src": "246:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 5999,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "246:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "245:9:7"
+                        },
+                        "returnParameters": {
+                            "id": 6002,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "263:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "232:32:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "39b37ab0",
+                        "id": 6008,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "fee",
+                        "nameLocation": "316:3:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6006,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6005,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6008,
+                                    "src": "320:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6004,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "320:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "319:9:7"
+                        },
+                        "returnParameters": {
+                            "id": 6007,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "337:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "307:31:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "4049ddd2",
+                        "id": 6013,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "chainId",
+                        "nameLocation": "377:7:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6011,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6010,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6013,
+                                    "src": "385:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6009,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "385:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "384:9:7"
+                        },
+                        "returnParameters": {
+                            "id": 6012,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "402:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "368:35:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "667f9d70",
+                        "id": 6022,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "load",
+                        "nameLocation": "473:4:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6018,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6015,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6022,
+                                    "src": "478:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6014,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "478:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6017,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6022,
+                                    "src": "486:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 6016,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "486:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "477:17:7"
+                        },
+                        "returnParameters": {
+                            "id": 6021,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6020,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6022,
+                                    "src": "513:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 6019,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "513:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "512:9:7"
+                        },
+                        "scope": 6200,
+                        "src": "464:58:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "70ca10bb",
+                        "id": 6031,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "store",
+                        "nameLocation": "606:5:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6029,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6024,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6031,
+                                    "src": "612:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6023,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "612:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6026,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6031,
+                                    "src": "620:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 6025,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "620:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6028,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6031,
+                                    "src": "628:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 6027,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "628:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "611:25:7"
+                        },
+                        "returnParameters": {
+                            "id": 6030,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "645:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "597:49:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "e341eaa4",
+                        "id": 6044,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "sign",
+                        "nameLocation": "713:4:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6036,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6033,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6044,
+                                    "src": "718:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6032,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "718:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6035,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6044,
+                                    "src": "726:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 6034,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "726:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "717:17:7"
+                        },
+                        "returnParameters": {
+                            "id": 6043,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6038,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6044,
+                                    "src": "753:5:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint8",
+                                        "typeString": "uint8"
+                                    },
+                                    "typeName": {
+                                        "id": 6037,
+                                        "name": "uint8",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "753:5:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint8",
+                                            "typeString": "uint8"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6040,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6044,
+                                    "src": "759:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 6039,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "759:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6042,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6044,
+                                    "src": "767:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes32",
+                                        "typeString": "bytes32"
+                                    },
+                                    "typeName": {
+                                        "id": 6041,
+                                        "name": "bytes32",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "767:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes32",
+                                            "typeString": "bytes32"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "752:23:7"
+                        },
+                        "scope": 6200,
+                        "src": "704:72:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "ffa18649",
+                        "id": 6051,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "addr",
+                        "nameLocation": "861:4:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6047,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6046,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6051,
+                                    "src": "866:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6045,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "866:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "865:9:7"
+                        },
+                        "returnParameters": {
+                            "id": 6050,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6049,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6051,
+                                    "src": "893:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6048,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "893:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "892:9:7"
+                        },
+                        "scope": 6200,
+                        "src": "852:50:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "2d0335ab",
+                        "id": 6058,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "getNonce",
+                        "nameLocation": "952:8:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6054,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6053,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6058,
+                                    "src": "961:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6052,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "961:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "960:9:7"
+                        },
+                        "returnParameters": {
+                            "id": 6057,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6056,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6058,
+                                    "src": "988:6:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint64",
+                                        "typeString": "uint64"
+                                    },
+                                    "typeName": {
+                                        "id": 6055,
+                                        "name": "uint64",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "988:6:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint64",
+                                            "typeString": "uint64"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "987:8:7"
+                        },
+                        "scope": 6200,
+                        "src": "943:53:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "f8e18b57",
+                        "id": 6065,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "setNonce",
+                        "nameLocation": "1100:8:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6063,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6060,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6065,
+                                    "src": "1109:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6059,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1109:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6062,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6065,
+                                    "src": "1118:6:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint64",
+                                        "typeString": "uint64"
+                                    },
+                                    "typeName": {
+                                        "id": 6061,
+                                        "name": "uint64",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1118:6:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint64",
+                                            "typeString": "uint64"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1108:17:7"
+                        },
+                        "returnParameters": {
+                            "id": 6064,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1134:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "1091:44:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "89160467",
+                        "id": 6073,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "ffi",
+                        "nameLocation": "1230:3:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6069,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6068,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6073,
+                                    "src": "1234:17:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "calldata",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_array$_t_string_calldata_ptr_$dyn_calldata_ptr",
+                                        "typeString": "string[]"
+                                    },
+                                    "typeName": {
+                                        "baseType": {
+                                            "id": 6066,
+                                            "name": "string",
+                                            "nodeType": "ElementaryTypeName",
+                                            "src": "1234:6:7",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_string_storage_ptr",
+                                                "typeString": "string"
+                                            }
+                                        },
+                                        "id": 6067,
+                                        "nodeType": "ArrayTypeName",
+                                        "src": "1234:8:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_string_storage_$dyn_storage_ptr",
+                                            "typeString": "string[]"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1233:19:7"
+                        },
+                        "returnParameters": {
+                            "id": 6072,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6071,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6073,
+                                    "src": "1271:12:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 6070,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1271:5:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1270:14:7"
+                        },
+                        "scope": 6200,
+                        "src": "1221:64:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "ca669fa7",
+                        "id": 6078,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "prank",
+                        "nameLocation": "1364:5:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6076,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6075,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6078,
+                                    "src": "1370:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6074,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1370:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1369:9:7"
+                        },
+                        "returnParameters": {
+                            "id": 6077,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1387:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "1355:33:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "06447d56",
+                        "id": 6083,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startPrank",
+                        "nameLocation": "1499:10:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6081,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6080,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6083,
+                                    "src": "1510:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6079,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1510:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1509:9:7"
+                        },
+                        "returnParameters": {
+                            "id": 6082,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1527:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "1490:38:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "47e50cce",
+                        "id": 6090,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "prank",
+                        "nameLocation": "1649:5:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6088,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6085,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6090,
+                                    "src": "1655:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6084,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1655:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6087,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6090,
+                                    "src": "1663:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6086,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1663:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1654:17:7"
+                        },
+                        "returnParameters": {
+                            "id": 6089,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1680:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "1640:41:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "45b56078",
+                        "id": 6097,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "startPrank",
+                        "nameLocation": "1834:10:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6095,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6092,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6097,
+                                    "src": "1845:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6091,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1845:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6094,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6097,
+                                    "src": "1853:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6093,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "1853:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "1844:17:7"
+                        },
+                        "returnParameters": {
+                            "id": 6096,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1870:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "1825:46:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "90c5013b",
+                        "id": 6100,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "stopPrank",
+                        "nameLocation": "1950:9:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6098,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1959:2:7"
+                        },
+                        "returnParameters": {
+                            "id": 6099,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "1970:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "1941:30:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "c88a5e6d",
+                        "id": 6107,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "deal",
+                        "nameLocation": "2036:4:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6105,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6102,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6107,
+                                    "src": "2041:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6101,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2041:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6104,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6107,
+                                    "src": "2050:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6103,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2050:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2040:18:7"
+                        },
+                        "returnParameters": {
+                            "id": 6106,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2067:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "2027:41:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "d82555f1",
+                        "id": 6116,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "tip",
+                        "nameLocation": "2082:3:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6114,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6109,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6116,
+                                    "src": "2086:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6108,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2086:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6111,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6116,
+                                    "src": "2095:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6110,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2095:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6113,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6116,
+                                    "src": "2104:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    },
+                                    "typeName": {
+                                        "id": 6112,
+                                        "name": "uint256",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2104:7:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_uint256",
+                                            "typeString": "uint256"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2085:27:7"
+                        },
+                        "returnParameters": {
+                            "id": 6115,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2121:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "2073:49:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "b4d6c782",
+                        "id": 6123,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "etch",
+                        "nameLocation": "2181:4:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6121,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6118,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6123,
+                                    "src": "2186:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6117,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2186:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6120,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6123,
+                                    "src": "2195:14:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "calldata",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_calldata_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 6119,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2195:5:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2185:25:7"
+                        },
+                        "returnParameters": {
+                            "id": 6122,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2219:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "2172:48:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "f28dceb3",
+                        "id": 6128,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "expectRevert",
+                        "nameLocation": "2271:12:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6126,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6125,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6128,
+                                    "src": "2284:14:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "calldata",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_calldata_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 6124,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2284:5:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2283:16:7"
+                        },
+                        "returnParameters": {
+                            "id": 6127,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2308:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "2262:47:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "c31eb0e0",
+                        "id": 6133,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "expectRevert",
+                        "nameLocation": "2323:12:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6131,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6130,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6133,
+                                    "src": "2336:6:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes4",
+                                        "typeString": "bytes4"
+                                    },
+                                    "typeName": {
+                                        "id": 6129,
+                                        "name": "bytes4",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2336:6:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes4",
+                                            "typeString": "bytes4"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2335:8:7"
+                        },
+                        "returnParameters": {
+                            "id": 6132,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2352:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "2314:39:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "f4844814",
+                        "id": 6136,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "expectRevert",
+                        "nameLocation": "2367:12:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6134,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2379:2:7"
+                        },
+                        "returnParameters": {
+                            "id": 6135,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2390:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "2358:33:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "266cf109",
+                        "id": 6139,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "record",
+                        "nameLocation": "2448:6:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6137,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2454:2:7"
+                        },
+                        "returnParameters": {
+                            "id": 6138,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "2465:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "2439:27:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "65bc9481",
+                        "id": 6150,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "accesses",
+                        "nameLocation": "2572:8:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6142,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6141,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6150,
+                                    "src": "2581:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6140,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "2581:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2580:9:7"
+                        },
+                        "returnParameters": {
+                            "id": 6149,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6145,
+                                    "mutability": "mutable",
+                                    "name": "reads",
+                                    "nameLocation": "2625:5:7",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6150,
+                                    "src": "2608:22:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                        "typeString": "bytes32[]"
+                                    },
+                                    "typeName": {
+                                        "baseType": {
+                                            "id": 6143,
+                                            "name": "bytes32",
+                                            "nodeType": "ElementaryTypeName",
+                                            "src": "2608:7:7",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "id": 6144,
+                                        "nodeType": "ArrayTypeName",
+                                        "src": "2608:9:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                            "typeString": "bytes32[]"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6148,
+                                    "mutability": "mutable",
+                                    "name": "writes",
+                                    "nameLocation": "2649:6:7",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6150,
+                                    "src": "2632:23:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr",
+                                        "typeString": "bytes32[]"
+                                    },
+                                    "typeName": {
+                                        "baseType": {
+                                            "id": 6146,
+                                            "name": "bytes32",
+                                            "nodeType": "ElementaryTypeName",
+                                            "src": "2632:7:7",
+                                            "typeDescriptions": {
+                                                "typeIdentifier": "t_bytes32",
+                                                "typeString": "bytes32"
+                                            }
+                                        },
+                                        "id": 6147,
+                                        "nodeType": "ArrayTypeName",
+                                        "src": "2632:9:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr",
+                                            "typeString": "bytes32[]"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "2607:49:7"
+                        },
+                        "scope": 6200,
+                        "src": "2563:94:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "491cc7c2",
+                        "id": 6161,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "expectEmit",
+                        "nameLocation": "2999:10:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6159,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6152,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6161,
+                                    "src": "3010:4:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 6151,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3010:4:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6154,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6161,
+                                    "src": "3015:4:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 6153,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3015:4:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6156,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6161,
+                                    "src": "3020:4:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 6155,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3020:4:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6158,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6161,
+                                    "src": "3025:4:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 6157,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3025:4:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "3009:21:7"
+                        },
+                        "returnParameters": {
+                            "id": 6160,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3039:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "2990:50:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "b96213e4",
+                        "id": 6170,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "mockCall",
+                        "nameLocation": "3304:8:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6168,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6163,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6170,
+                                    "src": "3313:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6162,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3313:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6165,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6170,
+                                    "src": "3321:14:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "calldata",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_calldata_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 6164,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3321:5:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6167,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6170,
+                                    "src": "3336:14:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "calldata",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_calldata_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 6166,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3336:5:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "3312:39:7"
+                        },
+                        "returnParameters": {
+                            "id": 6169,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3360:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "3295:66:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "3fdf4e15",
+                        "id": 6173,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "clearMockedCalls",
+                        "nameLocation": "3406:16:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6171,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3422:2:7"
+                        },
+                        "returnParameters": {
+                            "id": 6172,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3433:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "3397:37:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "bd6af434",
+                        "id": 6180,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "expectCall",
+                        "nameLocation": "3568:10:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6178,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6175,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6180,
+                                    "src": "3579:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6174,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3579:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6177,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6180,
+                                    "src": "3587:14:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "calldata",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_calldata_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 6176,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3587:5:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "3578:24:7"
+                        },
+                        "returnParameters": {
+                            "id": 6179,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3611:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "3559:53:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "8d1cc925",
+                        "id": 6187,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "getCode",
+                        "nameLocation": "3714:7:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6183,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6182,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6187,
+                                    "src": "3722:15:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "calldata",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_calldata_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 6181,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3722:6:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "3721:17:7"
+                        },
+                        "returnParameters": {
+                            "id": 6186,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6185,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6187,
+                                    "src": "3757:12:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "memory",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bytes_memory_ptr",
+                                        "typeString": "bytes"
+                                    },
+                                    "typeName": {
+                                        "id": 6184,
+                                        "name": "bytes",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3757:5:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bytes_storage_ptr",
+                                            "typeString": "bytes"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "3756:14:7"
+                        },
+                        "scope": 6200,
+                        "src": "3705:66:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "c657c718",
+                        "id": 6194,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "label",
+                        "nameLocation": "3825:5:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6192,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6189,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6194,
+                                    "src": "3831:7:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_address",
+                                        "typeString": "address"
+                                    },
+                                    "typeName": {
+                                        "id": 6188,
+                                        "name": "address",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3831:7:7",
+                                        "stateMutability": "nonpayable",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_address",
+                                            "typeString": "address"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                },
+                                {
+                                    "constant": false,
+                                    "id": 6191,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6194,
+                                    "src": "3840:15:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "calldata",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_string_calldata_ptr",
+                                        "typeString": "string"
+                                    },
+                                    "typeName": {
+                                        "id": 6190,
+                                        "name": "string",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3840:6:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_string_storage_ptr",
+                                            "typeString": "string"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "3830:26:7"
+                        },
+                        "returnParameters": {
+                            "id": 6193,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3865:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "3816:50:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    },
+                    {
+                        "functionSelector": "4c63e562",
+                        "id": 6199,
+                        "implemented": false,
+                        "kind": "function",
+                        "modifiers": [],
+                        "name": "assume",
+                        "nameLocation": "3967:6:7",
+                        "nodeType": "FunctionDefinition",
+                        "parameters": {
+                            "id": 6197,
+                            "nodeType": "ParameterList",
+                            "parameters": [
+                                {
+                                    "constant": false,
+                                    "id": 6196,
+                                    "mutability": "mutable",
+                                    "name": "",
+                                    "nameLocation": "-1:-1:-1",
+                                    "nodeType": "VariableDeclaration",
+                                    "scope": 6199,
+                                    "src": "3974:4:7",
+                                    "stateVariable": false,
+                                    "storageLocation": "default",
+                                    "typeDescriptions": {
+                                        "typeIdentifier": "t_bool",
+                                        "typeString": "bool"
+                                    },
+                                    "typeName": {
+                                        "id": 6195,
+                                        "name": "bool",
+                                        "nodeType": "ElementaryTypeName",
+                                        "src": "3974:4:7",
+                                        "typeDescriptions": {
+                                            "typeIdentifier": "t_bool",
+                                            "typeString": "bool"
+                                        }
+                                    },
+                                    "visibility": "internal"
+                                }
+                            ],
+                            "src": "3973:6:7"
+                        },
+                        "returnParameters": {
+                            "id": 6198,
+                            "nodeType": "ParameterList",
+                            "parameters": [],
+                            "src": "3988:0:7"
+                        },
+                        "scope": 6200,
+                        "src": "3958:31:7",
+                        "stateMutability": "nonpayable",
+                        "virtual": false,
+                        "visibility": "external"
+                    }
+                ],
+                "scope": 6201,
+                "src": "98:3893:7",
+                "usedErrors": []
+            }
+        ],
+        "src": "38:3954:7"
+    }
+}
diff --git a/test/SkewVault.t.sol b/test/SkewVault.t.sol
index c34cd2f..bed15f3 100644
--- a/test/SkewVault.t.sol
+++ b/test/SkewVault.t.sol
@@ -2,13 +2,16 @@
 pragma solidity ^0.8.10;
 
 import "../lib/ds-test/src/test.sol";
-import "../lib/foundry-playground/src/ERC20TokenFaker.sol";
-import "../lib/foundry-playground/src/FakeERC20.sol";
+import "./utils/ERC20TokenFaker.sol";
+import "./utils/FakeERC20.sol";
 import {LongFarmer} from "../contracts/LongFarmer.sol";
 import {SkewVault} from "../contracts/SkewVault.sol";
 import {ERC20} from "../lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
 import {SafeMath} from "../lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol";
 
+// import "../lib/forge-std/src/Test.sol";
+// import {VM} from "../lib/forge-std/src/Test.sol";
+
 interface Cheats {
     function warp(uint256 x) external;
 
@@ -16,10 +19,16 @@ interface Cheats {
 
     function roll(uint256) external;
 
-    function prank(address) external;
+    function prank(address, address) external;
+
+    function tip(
+        address,
+        address,
+        uint256
+    ) external;
 }
 
-contract SkewVaulttest is DSTest {
+contract SkewVaulttest is DSTest, ERC20TokenFaker {
     using SafeMath for uint256;
     LongFarmer longFarmer;
     SkewVault skewVault;
@@ -27,11 +36,13 @@ contract SkewVaulttest is DSTest {
     FakeERC20 longT;
     ERC20 tUSD;
     event Log(string);
+    ERC20 usdc = ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6);
 
     Cheats cheats = Cheats(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
 
     // Use below for forked network testing
     // forge test -vvv --fork-url https://arb-rinkeby.g.alchemy.com/v2/2LMiiNiXkk1CYIlXLjVFottvrUUnz4ps
+    // test-commit fails due to erc20 balances
 
     function setUp() public {
         fUSD = fakeOutERC20(address(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6));
@@ -50,7 +61,10 @@ contract SkewVaulttest is DSTest {
         longFarmer.setSkewVault(address(skewVault));
         skewVault.setLongFarmer(address(longFarmer));
         fUSD.approve(address(longFarmer), 1e18);
-        fUSD.allowance(address(0xC3d2052479dBC010480Ae16204777C1469CEffC9), address(longFarmer));
+        ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).allowance(
+            address(0xC3d2052479dBC010480Ae16204777C1469CEffC9),
+            address(longFarmer)
+        );
     }
 
     function testDeposit() public {
@@ -75,24 +89,18 @@ contract SkewVaulttest is DSTest {
         longFarmer._swap(10000000, _lP);
     }
 
+    // Fails due to ERC20 balances not being updated in mainnet
     function testCommit() public {
-        fUSD._setBalance(address(longFarmer), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); // onlyPlayer
+        fUSD._setBalance(address(longFarmer), 1e18); // onlyPlayer
+        fUSD.approve(0xccC0350C209F6F01D071c3cdc20eEb5EE4A73d80, 1e18);
+        fUSD.approve(0xC3d2052479dBC010480Ae16204777C1469CEffC9, 1e18);
+        fUSD.approve(0x8155a758a06E7e385191C119D35195Aa743cBe9f, 1e18);
+        ERC20(0x9e062eee2c0Ab96e1E1c8cE38bF14bA3fa0a35F6).allowance(
+            address(longFarmer),
+            0x8155a758a06E7e385191C119D35195Aa743cBe9f
+        );
         longFarmer.setActive();
-        longFarmer.acquire(100000);
+        longFarmer.acquire(10000);
         emit Log("commit");
-        // VM.roll(1 days);
-        // ERC20(0x4AaDc48087b569dD3E65dBe65B0dD036891767e3).approve(0xC3d2052479dBC010480Ae16204777C1469CEffC9, 1e18);
-        // longFarmer.dispose(1000);
-        // emit Log("commit burn");
-        // VM.roll(1 days);
-        // assert(ERC20(0x4AaDc48087b569dD3E65dBe65B0dD036891767e3).balanceOf(address(longFarmer)) < 10000000);
-        // longT = fakeOutERC20(address(0x4AaDc48087b569dD3E65dBe65B0dD036891767e3)); // 7x Long ETH
-        // longT._setBalance(address(longFarmer), 10000000000000000000000000);
-        // longT._setBalance(address(this), 10000000000000000000000000);
-        // longT.approve(0xC3d2052479dBC010480Ae16204777C1469CEffC9, 1e18);
-        // longT.approve(address(longFarmer), 1e18);
-        // uint256 want = 100;
-
-        // longFarmer.dispose(want);
     }
 }

From ed768fe1b3c862286cb67fe3cb3b6f53a34dbe1a Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Tue, 26 Apr 2022 14:10:40 +1000
Subject: [PATCH 44/45] balances to longfarmer

---
 contracts/LongFarmer.sol | 3 +++
 contracts/SkewVault.sol  | 1 -
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/contracts/LongFarmer.sol b/contracts/LongFarmer.sol
index 8c24f61..1201b52 100644
--- a/contracts/LongFarmer.sol
+++ b/contracts/LongFarmer.sol
@@ -49,6 +49,7 @@ contract LongFarmer is Ownable {
     uint256 public threshold;
     uint256 window;
     uint256 public depUSDC; //deposited USDC
+    uint256 public balances; //net user balances
     ILeveragedPool public pool;
     L2Encoder encoder;
     event unwind(uint256 _amt);
@@ -297,10 +298,12 @@ contract LongFarmer is Ownable {
     function rxFunds(uint256 _amt) public {
         USDC.transferFrom(address(skewVault), address(this), _amt);
         depUSDC += _amt;
+        balances += _amt;
     }
 
     function returnFunds(uint256 amount) public {
         USDC.transfer(address(skewVault), amount);
+        balances -= amount;
     }
 
     modifier onlyPlayer() {
diff --git a/contracts/SkewVault.sol b/contracts/SkewVault.sol
index a335d23..e30b74c 100644
--- a/contracts/SkewVault.sol
+++ b/contracts/SkewVault.sol
@@ -48,7 +48,6 @@ contract SkewVault is ERC4626, Ownable {
 
     function afterDeposit(uint256 assets, uint256 shares) internal virtual override {
         require(whiteList[msg.sender] == true);
-        // underlying.safeTransfer(address(longFarmer), assets);
         longFarmer.rxFunds(assets);
     }
 

From 19051ef4501d71319610bc333739f05ed3dd1741 Mon Sep 17 00:00:00 2001
From: 0xkoda <koda_0x@protonmail.com>
Date: Wed, 27 Apr 2022 10:31:01 +1000
Subject: [PATCH 45/45] constructor

---
 contracts/SkewVault.sol | 2 --
 1 file changed, 2 deletions(-)

diff --git a/contracts/SkewVault.sol b/contracts/SkewVault.sol
index e30b74c..cfdff52 100644
--- a/contracts/SkewVault.sol
+++ b/contracts/SkewVault.sol
@@ -22,8 +22,6 @@ contract SkewVault is ERC4626, Ownable {
 
     constructor(address _underlying) ERC4626(ERC20(_underlying), "TracerVault", "TVLT") {
         underlying = ERC20(_underlying);
-        // longFarmer = new LongFarmer();
-        // longFarmer.initialize(pooladdr, _threshold, _committer, _encoder, ERC20(this));
     }
 
     function totalAssets() public view override returns (uint256) {